VirtualBox

Changeset 26165 in vbox for trunk/src/VBox


Ignore:
Timestamp:
Feb 2, 2010 7:50:31 PM (15 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
57179
Message:

PDM: s/szDeviceName/szName/g - PDMDEVREG & PDMUSBREG.

Location:
trunk/src/VBox
Files:
32 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Devices/Audio/DevIchAc97.cpp

    r26160 r26165  
    16861686    /* u32Version */
    16871687    PDM_DEVREG_VERSION,
    1688     /* szDeviceName */
     1688    /* szName */
    16891689    "ichac97",
    16901690    /* szRCMod */
  • trunk/src/VBox/Devices/Audio/DevSB16.cpp

    r26001 r26165  
    19121912    /* u32Version */
    19131913    PDM_DEVREG_VERSION,
    1914     /* szDeviceName */
     1914    /* szName */
    19151915    "sb16",
    19161916    /* szRCMod */
  • trunk/src/VBox/Devices/Audio/audiosniffer.c

    r26160 r26165  
    197197    else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
    198198    {
    199         Log(("%s/%d: warning: no driver attached to LUN #0.\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     199        Log(("%s/%d: warning: no driver attached to LUN #0.\n", pDevIns->pReg->szName, pDevIns->iInstance));
    200200        rc = VINF_SUCCESS;
    201201    }
     
    226226    /* u32Version */
    227227    PDM_DEVREG_VERSION,
    228     /* szDeviceName */
     228    /* szName */
    229229    "AudioSniffer",
    230230    /* szRCMod */
  • trunk/src/VBox/Devices/Bus/DevPCI.cpp

    r26160 r26165  
    21302130    /* u32Version */
    21312131    PDM_DEVREG_VERSION,
    2132     /* szDeviceName */
     2132    /* szName */
    21332133    "pci",
    21342134    /* szRCMod */
     
    24922492    /* u32Version */
    24932493    PDM_DEVREG_VERSION,
    2494     /* szDeviceName */
     2494    /* szName */
    24952495    "pcibridge",
    24962496    /* szRCMod */
  • trunk/src/VBox/Devices/EFI/DevEFI.cpp

    r26160 r26165  
    10351035    /* u32Version */
    10361036    PDM_DEVREG_VERSION,
    1037     /* szDeviceName */
     1037    /* szName */
    10381038    "efi",
    10391039    /* szRCMod */
  • trunk/src/VBox/Devices/Graphics/DevVGA.cpp

    r26160 r26165  
    57595759            else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
    57605760            {
    5761                 Log(("%s/%d: warning: no driver attached to LUN #0!\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     5761                Log(("%s/%d: warning: no driver attached to LUN #0!\n", pDevIns->pReg->szName, pDevIns->iInstance));
    57625762                rc = VINF_SUCCESS;
    57635763            }
     
    65936593    /* u32Version */
    65946594    PDM_DEVREG_VERSION,
    6595     /* szDeviceName */
     6595    /* szName */
    65966596    "vga",
    65976597    /* szRCMod */
  • trunk/src/VBox/Devices/Input/DevPS2.cpp

    r26160 r26165  
    14721472            else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
    14731473            {
    1474                 Log(("%s/%d: warning: no driver attached to LUN #0!\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     1474                Log(("%s/%d: warning: no driver attached to LUN #0!\n", pDevIns->pReg->szName, pDevIns->iInstance));
    14751475                rc = VINF_SUCCESS;
    14761476            }
     
    14931493            else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
    14941494            {
    1495                 Log(("%s/%d: warning: no driver attached to LUN #1!\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     1495                Log(("%s/%d: warning: no driver attached to LUN #1!\n", pDevIns->pReg->szName, pDevIns->iInstance));
    14961496                rc = VINF_SUCCESS;
    14971497            }
     
    16831683    /* u32Version */
    16841684    PDM_DEVREG_VERSION,
    1685     /* szDeviceName */
     1685    /* szName */
    16861686    "pckbd",
    16871687    /* szRCMod */
  • trunk/src/VBox/Devices/Network/DevINIP.cpp

    r26160 r26165  
    678678    /* u32Version */
    679679    PDM_DEVREG_VERSION,
    680     /* szDeviceName */
     680    /* szName */
    681681    "IntNetIP",
    682682    /* szRCMod/szR0Mod */
  • trunk/src/VBox/Devices/Network/DevPCNet.cpp

    r26160 r26165  
    53005300    /* u32Version */
    53015301    PDM_DEVREG_VERSION,
    5302     /* szDeviceName */
     5302    /* szName */
    53035303    "pcnet",
    53045304    /* szRCMod */
  • trunk/src/VBox/Devices/PC/DevACPI.cpp

    r26160 r26165  
    24842484   {
    24852485       Log(("acpi: %s/%d: warning: no driver attached to LUN #0!\n",
    2486             pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     2486            pDevIns->pReg->szName, pDevIns->iInstance));
    24872487       rc = VINF_SUCCESS;
    24882488   }
     
    25002500    /* u32Version */
    25012501    PDM_DEVREG_VERSION,
    2502     /* szDeviceName */
     2502    /* szName */
    25032503    "acpi",
    25042504    /* szRCMod */
  • trunk/src/VBox/Devices/PC/DevAPIC.cpp

    r26157 r26165  
    29942994    /* u32Version */
    29952995    PDM_DEVREG_VERSION,
    2996     /* szDeviceName */
     2996    /* szName */
    29972997    "apic",
    29982998    /* szRCMod */
     
    33153315    /* u32Version */
    33163316    PDM_DEVREG_VERSION,
    3317     /* szDeviceName */
     3317    /* szName */
    33183318    "ioapic",
    33193319    /* szRCMod */
  • trunk/src/VBox/Devices/PC/DevDMA.cpp

    r26160 r26165  
    934934    /* u32Version */
    935935    PDM_DEVREG_VERSION,
    936     /* szDeviceName */
     936    /* szName */
    937937    "8237A",
    938938    /* szRCMod */
  • trunk/src/VBox/Devices/PC/DevPIC.cpp

    r26157 r26165  
    10791079    /* u32Version */
    10801080    PDM_DEVREG_VERSION,
    1081     /* szDeviceName */
     1081    /* szName */
    10821082    "i8259",
    10831083    /* szRCMod */
  • trunk/src/VBox/Devices/PC/DevPcArch.c

    r26164 r26165  
    255255    /* u32Version */
    256256    PDM_DEVREG_VERSION,
    257     /* szDeviceName */
     257    /* szName */
    258258    "pcarch",
    259259    /* szRCMod */
  • trunk/src/VBox/Devices/PC/DevPcBios.cpp

    r26160 r26165  
    13091309    /* u32Version */
    13101310    PDM_DEVREG_VERSION,
    1311     /* szDeviceName */
     1311    /* szName */
    13121312    "pcbios",
    13131313    /* szRCMod */
  • trunk/src/VBox/Devices/PC/DevPit-i8254.cpp

    r26160 r26165  
    10941094    /* u32Version */
    10951095    PDM_DEVREG_VERSION,
    1096     /* szDeviceName */
     1096    /* szName */
    10971097    "i8254",
    10981098    /* szRCMod */
  • trunk/src/VBox/Devices/PC/DevRTC.cpp

    r26160 r26165  
    987987    /* u32Version */
    988988    PDM_DEVREG_VERSION,
    989     /* szDeviceName */
     989    /* szName */
    990990    "mc146818",
    991991    /* szRCMod */
  • trunk/src/VBox/Devices/Parallel/DevParallel.cpp

    r26160 r26165  
    856856    /* u32Version */
    857857    PDM_DEVREG_VERSION,
    858     /* szDeviceName */
     858    /* szName */
    859859    "parallel",
    860860    /* szRCMod */
  • trunk/src/VBox/Devices/Samples/VBoxSampleDevice.cpp

    r26157 r26165  
    9898    /* u32Version */
    9999    PDM_DEVREG_VERSION,
    100     /* szDeviceName */
     100    /* szName */
    101101    "sample",
    102102    /* szRCMod */
  • trunk/src/VBox/Devices/Serial/DevSerial.cpp

    r26160 r26165  
    975975    /* u32Version */
    976976    PDM_DEVREG_VERSION,
    977     /* szDeviceName */
     977    /* szName */
    978978    "serial",
    979979    /* szRCMod */
  • trunk/src/VBox/Devices/Storage/DevAHCI.cpp

    r26160 r26165  
    69666966    /* u32Version */
    69676967    PDM_DEVREG_VERSION,
    6968     /* szDeviceName */
     6968    /* szName */
    69696969    "ahci",
    69706970    /* szRCMod */
  • trunk/src/VBox/Devices/Storage/DevATA.cpp

    r26160 r26165  
    69836983    /* u32Version */
    69846984    PDM_DEVREG_VERSION,
    6985     /* szDeviceName */
     6985    /* szName */
    69866986    "piix3ide",
    69876987    /* szRCMod */
  • trunk/src/VBox/Devices/Storage/DevBusLogic.cpp

    r26160 r26165  
    26782678    /* u32Version */
    26792679    PDM_DEVREG_VERSION,
    2680     /* szDeviceName */
     2680    /* szName */
    26812681    "buslogic",
    26822682    /* szRCMod */
  • trunk/src/VBox/Devices/Storage/DevLsiLogicSCSI.cpp

    r26157 r26165  
    46554655    /* u32Version */
    46564656    PDM_DEVREG_VERSION,
    4657     /* szDeviceName */
     4657    /* szName */
    46584658    "lsilogicscsi",
    46594659    /* szRCMod */
  • trunk/src/VBox/Devices/Storage/fdc.c

    r26160 r26165  
    29132913    /* u32Version */
    29142914    PDM_DEVREG_VERSION,
    2915     /* szDeviceName */
     2915    /* szName */
    29162916    "i82078",
    29172917    /* szRCMod */
  • trunk/src/VBox/Devices/VMMDev/VMMDev.cpp

    r26164 r26165  
    26872687    else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
    26882688    {
    2689         Log(("%s/%d: warning: no driver attached to LUN #0!\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     2689        Log(("%s/%d: warning: no driver attached to LUN #0!\n", pDevIns->pReg->szName, pDevIns->iInstance));
    26902690        rc = VINF_SUCCESS;
    26912691    }
     
    27342734    /* u32Version */
    27352735    PDM_DEVREG_VERSION,
    2736     /* szDeviceName */
     2736    /* szName */
    27372737    "VMMDev",
    27382738    /* szRCMod */
  • trunk/src/VBox/VMM/PDM.cpp

    r26163 r26165  
    471471            {
    472472                LogFlow(("PDMR3Relocate: Relocating device '%s'/%d\n",
    473                          pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     473                         pDevIns->pReg->szName, pDevIns->iInstance));
    474474                pDevIns->pReg->pfnRelocate(pDevIns, offDelta);
    475475            }
     
    544544    for (PPDMUSBINS pUsbIns = pVM->pdm.s.pUsbInstances; pUsbIns; pUsbIns = pUsbIns->Internal.s.pNext)
    545545    {
    546         pdmR3TermLuns(pVM, pUsbIns->Internal.s.pLuns, pUsbIns->pReg->szDeviceName, pUsbIns->iInstance);
     546        pdmR3TermLuns(pVM, pUsbIns->Internal.s.pLuns, pUsbIns->pReg->szName, pUsbIns->iInstance);
    547547
    548548        if (pUsbIns->pReg->pfnDestruct)
    549549        {
    550550            LogFlow(("pdmR3DevTerm: Destroying - device '%s'/%d\n",
    551                      pUsbIns->pReg->szDeviceName, pUsbIns->iInstance));
     551                     pUsbIns->pReg->szName, pUsbIns->iInstance));
    552552            pUsbIns->pReg->pfnDestruct(pUsbIns);
    553553        }
     
    561561    for (PPDMDEVINS pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextR3)
    562562    {
    563         pdmR3TermLuns(pVM, pDevIns->Internal.s.pLunsR3, pDevIns->pReg->szDeviceName, pDevIns->iInstance);
     563        pdmR3TermLuns(pVM, pDevIns->Internal.s.pLunsR3, pDevIns->pReg->szName, pDevIns->iInstance);
    564564
    565565        if (pDevIns->pReg->pfnDestruct)
    566566        {
    567567            LogFlow(("pdmR3DevTerm: Destroying - device '%s'/%d\n",
    568                      pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     568                     pDevIns->pReg->szName, pDevIns->iInstance));
    569569            pDevIns->pReg->pfnDestruct(pDevIns);
    570570        }
     
    640640    {
    641641        SSMR3PutU32(pSSM, i);
    642         SSMR3PutStrZ(pSSM, pDevIns->pReg->szDeviceName);
     642        SSMR3PutStrZ(pSSM, pDevIns->pReg->szName);
    643643        SSMR3PutU32(pSSM, pDevIns->iInstance);
    644644    }
     
    867867
    868868        /* Get the name and instance number. */
    869         char szDeviceName[RT_SIZEOFMEMB(PDMDEVREG, szDeviceName)];
    870         rc = SSMR3GetStrZ(pSSM, szDeviceName, sizeof(szDeviceName));
     869        char szName[RT_SIZEOFMEMB(PDMDEVREG, szName)];
     870        rc = SSMR3GetStrZ(pSSM, szName, sizeof(szName));
    871871        if (RT_FAILURE(rc))
    872872            return rc;
     
    879879        PPDMDEVINS pDevIns;
    880880        for (pDevIns = pVM->pdm.s.pDevInstances; pDevIns; pDevIns = pDevIns->Internal.s.pNextR3)
    881             if (   !strcmp(szDeviceName, pDevIns->pReg->szDeviceName)
     881            if (   !strcmp(szName, pDevIns->pReg->szName)
    882882                && pDevIns->iInstance == iInstance)
    883883            {
    884884                AssertLogRelMsgReturn(!(pDevIns->Internal.s.fIntFlags & PDMDEVINSINT_FLAGS_FOUND),
    885                                       ("%s/#%u\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance),
     885                                      ("%s/#%u\n", pDevIns->pReg->szName, pDevIns->iInstance),
    886886                                      VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
    887887                pDevIns->Internal.s.fIntFlags |= PDMDEVINSINT_FLAGS_FOUND;
     
    890890        if (!pDevIns)
    891891        {
    892             LogRel(("Device '%s'/%d not found in current config\n", szDeviceName, iInstance));
     892            LogRel(("Device '%s'/%d not found in current config\n", szName, iInstance));
    893893            if (SSMR3HandleGetAfter(pSSM) != SSMAFTER_DEBUG_IT)
    894                 return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Device '%s'/%d not found in current config"), szDeviceName, iInstance);
     894                return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Device '%s'/%d not found in current config"), szName, iInstance);
    895895        }
    896896    }
     
    902902        if (!(pDevIns->Internal.s.fIntFlags & PDMDEVINSINT_FLAGS_FOUND))
    903903        {
    904             LogRel(("Device '%s'/%d not found in the saved state\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     904            LogRel(("Device '%s'/%d not found in the saved state\n", pDevIns->pReg->szName, pDevIns->iInstance));
    905905            if (SSMR3HandleGetAfter(pSSM) != SSMAFTER_DEBUG_IT)
    906906                return SSMR3SetCfgError(pSSM, RT_SRC_POS, N_("Device '%s'/%d not found in the saved state"),
    907                                         pDevIns->pReg->szDeviceName, pDevIns->iInstance);
     907                                        pDevIns->pReg->szName, pDevIns->iInstance);
    908908        }
    909909
     
    951951    if (pUsbIns->pReg->pfnVMPowerOn)
    952952    {
    953         LogFlow(("PDMR3PowerOn: Notifying - device '%s'/%d\n", pUsbIns->pReg->szDeviceName, pUsbIns->iInstance));
     953        LogFlow(("PDMR3PowerOn: Notifying - device '%s'/%d\n", pUsbIns->pReg->szName, pUsbIns->iInstance));
    954954        int rc = VINF_SUCCESS; pUsbIns->pReg->pfnVMPowerOn(pUsbIns);
    955955        if (RT_FAILURE(rc))
    956956        {
    957             LogRel(("PDMR3PowerOn: device '%s'/%d -> %Rrc\n", pUsbIns->pReg->szDeviceName, pUsbIns->iInstance, rc));
     957            LogRel(("PDMR3PowerOn: device '%s'/%d -> %Rrc\n", pUsbIns->pReg->szName, pUsbIns->iInstance, rc));
    958958            return rc;
    959959        }
     
    975975    if (pDevIns->pReg->pfnPowerOn)
    976976    {
    977         LogFlow(("PDMR3PowerOn: Notifying - device '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     977        LogFlow(("PDMR3PowerOn: Notifying - device '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
    978978        int rc = VINF_SUCCESS; pDevIns->pReg->pfnPowerOn(pDevIns);
    979979        if (RT_FAILURE(rc))
    980980        {
    981             LogRel(("PDMR3PowerOn: device '%s'/%d -> %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     981            LogRel(("PDMR3PowerOn: device '%s'/%d -> %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    982982            return rc;
    983983        }
     
    10071007        for (PPDMLUN pLun = pDevIns->Internal.s.pLunsR3;  pLun && RT_SUCCESS(rc);  pLun = pLun->pNext)
    10081008            for (PPDMDRVINS pDrvIns = pLun->pTop;  pDrvIns && RT_SUCCESS(rc);  pDrvIns = pDrvIns->Internal.s.pDown)
    1009                 rc = pdmR3PowerOnDrv(pDrvIns, pDevIns->pReg->szDeviceName, pDevIns->iInstance, pLun->iLun);
     1009                rc = pdmR3PowerOnDrv(pDrvIns, pDevIns->pReg->szName, pDevIns->iInstance, pLun->iLun);
    10101010        if (RT_SUCCESS(rc))
    10111011            rc = pdmR3PowerOnDev(pDevIns);
     
    10171017        for (PPDMLUN pLun = pUsbIns->Internal.s.pLuns;  pLun && RT_SUCCESS(rc);  pLun = pLun->pNext)
    10181018            for (PPDMDRVINS pDrvIns = pLun->pTop;  pDrvIns && RT_SUCCESS(rc);  pDrvIns = pDrvIns->Internal.s.pDown)
    1019                 rc = pdmR3PowerOnDrv(pDrvIns, pUsbIns->pReg->szDeviceName, pUsbIns->iInstance, pLun->iLun);
     1019                rc = pdmR3PowerOnDrv(pDrvIns, pUsbIns->pReg->szName, pUsbIns->iInstance, pLun->iLun);
    10201020        if (RT_SUCCESS(rc))
    10211021            rc = pdmR3PowerOnUsb(pUsbIns);
     
    10991099            if (!pUsbIns->Internal.s.pfnAsyncNotify)
    11001100            {
    1101                 LogFlow(("PDMR3Reset: Notifying - device '%s'/%d\n", pUsbIns->pReg->szDeviceName, pUsbIns->iInstance));
     1101                LogFlow(("PDMR3Reset: Notifying - device '%s'/%d\n", pUsbIns->pReg->szName, pUsbIns->iInstance));
    11021102                pUsbIns->pReg->pfnVMReset(pUsbIns);
    11031103                if (pUsbIns->Internal.s.pfnAsyncNotify)
    1104                     LogFlow(("PDMR3Reset: Async notification started - device '%s'/%d\n", pUsbIns->pReg->szDeviceName, pUsbIns->iInstance));
     1104                    LogFlow(("PDMR3Reset: Async notification started - device '%s'/%d\n", pUsbIns->pReg->szName, pUsbIns->iInstance));
    11051105            }
    11061106            else if (pUsbIns->Internal.s.pfnAsyncNotify(pUsbIns))
    11071107            {
    1108                 LogFlow(("PDMR3Reset: Async notification completed - device '%s'/%d\n", pUsbIns->pReg->szDeviceName, pUsbIns->iInstance));
     1108                LogFlow(("PDMR3Reset: Async notification completed - device '%s'/%d\n", pUsbIns->pReg->szName, pUsbIns->iInstance));
    11091109                pUsbIns->Internal.s.pfnAsyncNotify = NULL;
    11101110            }
     
    11341134            if (!pDevIns->Internal.s.pfnAsyncNotify)
    11351135            {
    1136                 LogFlow(("PDMR3Reset: Notifying - device '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     1136                LogFlow(("PDMR3Reset: Notifying - device '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
    11371137                pDevIns->pReg->pfnReset(pDevIns);
    11381138                if (pDevIns->Internal.s.pfnAsyncNotify)
    1139                     LogFlow(("PDMR3Reset: Async notification started - device '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     1139                    LogFlow(("PDMR3Reset: Async notification started - device '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
    11401140            }
    11411141            else if (pDevIns->Internal.s.pfnAsyncNotify(pDevIns))
    11421142            {
    1143                 LogFlow(("PDMR3Reset: Async notification completed - device '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     1143                LogFlow(("PDMR3Reset: Async notification completed - device '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
    11441144                pDevIns->Internal.s.pfnAsyncNotify = NULL;
    11451145            }
     
    12181218                for (PPDMLUN pLun = pDevIns->Internal.s.pLunsR3; pLun; pLun = pLun->pNext)
    12191219                    for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
    1220                         if (!pdmR3ResetDrv(pDrvIns, &cAsync, pDevIns->pReg->szDeviceName, pDevIns->iInstance, pLun->iLun))
     1220                        if (!pdmR3ResetDrv(pDrvIns, &cAsync, pDevIns->pReg->szName, pDevIns->iInstance, pLun->iLun))
    12211221                            break;
    12221222
     
    12321232            for (PPDMLUN pLun = pUsbIns->Internal.s.pLuns; pLun; pLun = pLun->pNext)
    12331233                for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
    1234                     if (!pdmR3ResetDrv(pDrvIns, &cAsync, pUsbIns->pReg->szDeviceName, pUsbIns->iInstance, pLun->iLun))
     1234                    if (!pdmR3ResetDrv(pDrvIns, &cAsync, pUsbIns->pReg->szName, pUsbIns->iInstance, pLun->iLun))
    12351235                        break;
    12361236
     
    13251325            if (!pUsbIns->Internal.s.pfnAsyncNotify)
    13261326            {
    1327                 LogFlow(("PDMR3Suspend: Notifying - device '%s'/%d\n", pUsbIns->pReg->szDeviceName, pUsbIns->iInstance));
     1327                LogFlow(("PDMR3Suspend: Notifying - device '%s'/%d\n", pUsbIns->pReg->szName, pUsbIns->iInstance));
    13281328                pUsbIns->pReg->pfnVMSuspend(pUsbIns);
    13291329                if (pUsbIns->Internal.s.pfnAsyncNotify)
    1330                     LogFlow(("PDMR3Suspend: Async notification started - device '%s'/%d\n", pUsbIns->pReg->szDeviceName, pUsbIns->iInstance));
     1330                    LogFlow(("PDMR3Suspend: Async notification started - device '%s'/%d\n", pUsbIns->pReg->szName, pUsbIns->iInstance));
    13311331            }
    13321332            else if (pUsbIns->Internal.s.pfnAsyncNotify(pUsbIns))
    13331333            {
    1334                 LogFlow(("PDMR3Suspend: Async notification completed - device '%s'/%d\n", pUsbIns->pReg->szDeviceName, pUsbIns->iInstance));
     1334                LogFlow(("PDMR3Suspend: Async notification completed - device '%s'/%d\n", pUsbIns->pReg->szName, pUsbIns->iInstance));
    13351335                pUsbIns->Internal.s.pfnAsyncNotify = NULL;
    13361336            }
     
    13601360            if (!pDevIns->Internal.s.pfnAsyncNotify)
    13611361            {
    1362                 LogFlow(("PDMR3Suspend: Notifying - device '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     1362                LogFlow(("PDMR3Suspend: Notifying - device '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
    13631363                pDevIns->pReg->pfnSuspend(pDevIns);
    13641364                if (pDevIns->Internal.s.pfnAsyncNotify)
    1365                     LogFlow(("PDMR3Suspend: Async notification started - device '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     1365                    LogFlow(("PDMR3Suspend: Async notification started - device '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
    13661366            }
    13671367            else if (pDevIns->Internal.s.pfnAsyncNotify(pDevIns))
    13681368            {
    1369                 LogFlow(("PDMR3Suspend: Async notification completed - device '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     1369                LogFlow(("PDMR3Suspend: Async notification completed - device '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
    13701370                pDevIns->Internal.s.pfnAsyncNotify = NULL;
    13711371            }
     
    14231423                for (PPDMLUN pLun = pDevIns->Internal.s.pLunsR3; pLun; pLun = pLun->pNext)
    14241424                    for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
    1425                         if (!pdmR3SuspendDrv(pDrvIns, &cAsync, pDevIns->pReg->szDeviceName, pDevIns->iInstance, pLun->iLun))
     1425                        if (!pdmR3SuspendDrv(pDrvIns, &cAsync, pDevIns->pReg->szName, pDevIns->iInstance, pLun->iLun))
    14261426                            break;
    14271427
     
    14381438            for (PPDMLUN pLun = pUsbIns->Internal.s.pLuns; pLun; pLun = pLun->pNext)
    14391439                for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
    1440                     if (!pdmR3SuspendDrv(pDrvIns, &cAsync, pUsbIns->pReg->szDeviceName, pUsbIns->iInstance, pLun->iLun))
     1440                    if (!pdmR3SuspendDrv(pDrvIns, &cAsync, pUsbIns->pReg->szName, pUsbIns->iInstance, pLun->iLun))
    14411441                        break;
    14421442
     
    15091509    if (pUsbIns->pReg->pfnVMResume)
    15101510    {
    1511         LogFlow(("PDMR3Resume: Notifying - device '%s'/%d\n", pUsbIns->pReg->szDeviceName, pUsbIns->iInstance));
     1511        LogFlow(("PDMR3Resume: Notifying - device '%s'/%d\n", pUsbIns->pReg->szName, pUsbIns->iInstance));
    15121512        int rc = VINF_SUCCESS; pUsbIns->pReg->pfnVMResume(pUsbIns);
    15131513        if (RT_FAILURE(rc))
    15141514        {
    1515             LogRel(("PDMR3Resume: device '%s'/%d -> %Rrc\n", pUsbIns->pReg->szDeviceName, pUsbIns->iInstance, rc));
     1515            LogRel(("PDMR3Resume: device '%s'/%d -> %Rrc\n", pUsbIns->pReg->szName, pUsbIns->iInstance, rc));
    15161516            return rc;
    15171517        }
     
    15331533    if (pDevIns->pReg->pfnResume)
    15341534    {
    1535         LogFlow(("PDMR3Resume: Notifying - device '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     1535        LogFlow(("PDMR3Resume: Notifying - device '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
    15361536        int rc = VINF_SUCCESS; pDevIns->pReg->pfnResume(pDevIns);
    15371537        if (RT_FAILURE(rc))
    15381538        {
    1539             LogRel(("PDMR3Resume: device '%s'/%d -> %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     1539            LogRel(("PDMR3Resume: device '%s'/%d -> %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    15401540            return rc;
    15411541        }
     
    15651565        for (PPDMLUN pLun = pDevIns->Internal.s.pLunsR3;  pLun && RT_SUCCESS(rc);  pLun    = pLun->pNext)
    15661566            for (PPDMDRVINS pDrvIns = pLun->pTop;  pDrvIns && RT_SUCCESS(rc);  pDrvIns = pDrvIns->Internal.s.pDown)
    1567                 rc = pdmR3ResumeDrv(pDrvIns, pDevIns->pReg->szDeviceName, pDevIns->iInstance, pLun->iLun);
     1567                rc = pdmR3ResumeDrv(pDrvIns, pDevIns->pReg->szName, pDevIns->iInstance, pLun->iLun);
    15681568        if (RT_SUCCESS(rc))
    15691569            rc = pdmR3ResumeDev(pDevIns);
     
    15751575        for (PPDMLUN pLun = pUsbIns->Internal.s.pLuns;  pLun && RT_SUCCESS(rc);  pLun = pLun->pNext)
    15761576            for (PPDMDRVINS pDrvIns = pLun->pTop;  pDrvIns && RT_SUCCESS(rc);  pDrvIns = pDrvIns->Internal.s.pDown)
    1577                 rc = pdmR3ResumeDrv(pDrvIns, pUsbIns->pReg->szDeviceName, pUsbIns->iInstance, pLun->iLun);
     1577                rc = pdmR3ResumeDrv(pDrvIns, pUsbIns->pReg->szName, pUsbIns->iInstance, pLun->iLun);
    15781578        if (RT_SUCCESS(rc))
    15791579            rc = pdmR3ResumeUsb(pUsbIns);
     
    16571657            if (!pUsbIns->Internal.s.pfnAsyncNotify)
    16581658            {
    1659                 LogFlow(("PDMR3PowerOff: Notifying - device '%s'/%d\n", pUsbIns->pReg->szDeviceName, pUsbIns->iInstance));
     1659                LogFlow(("PDMR3PowerOff: Notifying - device '%s'/%d\n", pUsbIns->pReg->szName, pUsbIns->iInstance));
    16601660                pUsbIns->pReg->pfnVMPowerOff(pUsbIns);
    16611661                if (pUsbIns->Internal.s.pfnAsyncNotify)
    1662                     LogFlow(("PDMR3PowerOff: Async notification started - device '%s'/%d\n", pUsbIns->pReg->szDeviceName, pUsbIns->iInstance));
     1662                    LogFlow(("PDMR3PowerOff: Async notification started - device '%s'/%d\n", pUsbIns->pReg->szName, pUsbIns->iInstance));
    16631663            }
    16641664            else if (pUsbIns->Internal.s.pfnAsyncNotify(pUsbIns))
    16651665            {
    1666                 LogFlow(("PDMR3PowerOff: Async notification completed - device '%s'/%d\n", pUsbIns->pReg->szDeviceName, pUsbIns->iInstance));
     1666                LogFlow(("PDMR3PowerOff: Async notification completed - device '%s'/%d\n", pUsbIns->pReg->szName, pUsbIns->iInstance));
    16671667                pUsbIns->Internal.s.pfnAsyncNotify = NULL;
    16681668            }
     
    16921692            if (!pDevIns->Internal.s.pfnAsyncNotify)
    16931693            {
    1694                 LogFlow(("PDMR3PowerOff: Notifying - device '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     1694                LogFlow(("PDMR3PowerOff: Notifying - device '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
    16951695                pDevIns->pReg->pfnPowerOff(pDevIns);
    16961696                if (pDevIns->Internal.s.pfnAsyncNotify)
    1697                     LogFlow(("PDMR3PowerOff: Async notification started - device '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     1697                    LogFlow(("PDMR3PowerOff: Async notification started - device '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
    16981698            }
    16991699            else if (pDevIns->Internal.s.pfnAsyncNotify(pDevIns))
    17001700            {
    1701                 LogFlow(("PDMR3PowerOff: Async notification completed - device '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     1701                LogFlow(("PDMR3PowerOff: Async notification completed - device '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
    17021702                pDevIns->Internal.s.pfnAsyncNotify = NULL;
    17031703            }
     
    17481748                for (PPDMLUN pLun = pDevIns->Internal.s.pLunsR3; pLun; pLun = pLun->pNext)
    17491749                    for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
    1750                         if (!pdmR3PowerOffDrv(pDrvIns, &cAsync, pDevIns->pReg->szDeviceName, pDevIns->iInstance, pLun->iLun))
     1750                        if (!pdmR3PowerOffDrv(pDrvIns, &cAsync, pDevIns->pReg->szName, pDevIns->iInstance, pLun->iLun))
    17511751                            break;
    17521752
     
    17631763            for (PPDMLUN pLun = pUsbIns->Internal.s.pLuns; pLun; pLun = pLun->pNext)
    17641764                for (PPDMDRVINS pDrvIns = pLun->pTop; pDrvIns; pDrvIns = pDrvIns->Internal.s.pDown)
    1765                     if (!pdmR3PowerOffDrv(pDrvIns, &cAsync, pUsbIns->pReg->szDeviceName, pUsbIns->iInstance, pLun->iLun))
     1765                    if (!pdmR3PowerOffDrv(pDrvIns, &cAsync, pUsbIns->pReg->szName, pUsbIns->iInstance, pLun->iLun))
    17661766                        break;
    17671767
     
    18201820    {
    18211821        if (    pDev->cchName == cchDevice
    1822             &&  !memcmp(pDev->pReg->szDeviceName, pszDevice, cchDevice))
     1822            &&  !memcmp(pDev->pReg->szName, pszDevice, cchDevice))
    18231823        {
    18241824            /*
  • trunk/src/VBox/VMM/PDMDevHlp.cpp

    r26160 r26165  
    6868{
    6969    PDMDEV_ASSERT_DEVINS(pDevIns);
    70     LogFlow(("pdmR3DevHlp_IOPortRegister: caller='%s'/%d: Port=%#x cPorts=%#x pvUser=%p pfnOut=%p pfnIn=%p pfnOutStr=%p pfnInStr=%p p32_tszDesc=%p:{%s}\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance,
     70    LogFlow(("pdmR3DevHlp_IOPortRegister: caller='%s'/%d: Port=%#x cPorts=%#x pvUser=%p pfnOut=%p pfnIn=%p pfnOutStr=%p pfnInStr=%p p32_tszDesc=%p:{%s}\n", pDevIns->pReg->szName, pDevIns->iInstance,
    7171             Port, cPorts, pvUser, pfnOut, pfnIn, pfnOutStr, pfnInStr, pszDesc, pszDesc));
    7272    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
     
    8383    int rc = IOMR3IOPortRegisterR3(pDevIns->Internal.s.pVMR3, pDevIns, Port, cPorts, pvUser, pfnOut, pfnIn, pfnOutStr, pfnInStr, pszDesc);
    8484
    85     LogFlow(("pdmR3DevHlp_IOPortRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     85    LogFlow(("pdmR3DevHlp_IOPortRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    8686    return rc;
    8787}
     
    9595    PDMDEV_ASSERT_DEVINS(pDevIns);
    9696    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    97     LogFlow(("pdmR3DevHlp_IOPortRegisterRC: caller='%s'/%d: Port=%#x cPorts=%#x pvUser=%p pszOut=%p:{%s} pszIn=%p:{%s} pszOutStr=%p:{%s} pszInStr=%p:{%s} pszDesc=%p:{%s}\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance,
     97    LogFlow(("pdmR3DevHlp_IOPortRegisterRC: caller='%s'/%d: Port=%#x cPorts=%#x pvUser=%p pszOut=%p:{%s} pszIn=%p:{%s} pszOutStr=%p:{%s} pszInStr=%p:{%s} pszDesc=%p:{%s}\n", pDevIns->pReg->szName, pDevIns->iInstance,
    9898             Port, cPorts, pvUser, pszOut, pszOut, pszIn, pszIn, pszOutStr, pszOutStr, pszInStr, pszInStr, pszDesc, pszDesc));
    9999
     
    150150    }
    151151
    152     LogFlow(("pdmR3DevHlp_IOPortRegisterRC: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     152    LogFlow(("pdmR3DevHlp_IOPortRegisterRC: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    153153    return rc;
    154154}
     
    162162    PDMDEV_ASSERT_DEVINS(pDevIns);
    163163    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    164     LogFlow(("pdmR3DevHlp_IOPortRegisterR0: caller='%s'/%d: Port=%#x cPorts=%#x pvUser=%p pszOut=%p:{%s} pszIn=%p:{%s} pszOutStr=%p:{%s} pszInStr=%p:{%s} pszDesc=%p:{%s}\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance,
     164    LogFlow(("pdmR3DevHlp_IOPortRegisterR0: caller='%s'/%d: Port=%#x cPorts=%#x pvUser=%p pszOut=%p:{%s} pszIn=%p:{%s} pszOutStr=%p:{%s} pszInStr=%p:{%s} pszDesc=%p:{%s}\n", pDevIns->pReg->szName, pDevIns->iInstance,
    165165             Port, cPorts, pvUser, pszOut, pszOut, pszIn, pszIn, pszOutStr, pszOutStr, pszInStr, pszInStr, pszDesc, pszDesc));
    166166
     
    217217    }
    218218
    219     LogFlow(("pdmR3DevHlp_IOPortRegisterR0: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     219    LogFlow(("pdmR3DevHlp_IOPortRegisterR0: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    220220    return rc;
    221221}
     
    227227    PDMDEV_ASSERT_DEVINS(pDevIns);
    228228    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    229     LogFlow(("pdmR3DevHlp_IOPortDeregister: caller='%s'/%d: Port=%#x cPorts=%#x\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance,
     229    LogFlow(("pdmR3DevHlp_IOPortDeregister: caller='%s'/%d: Port=%#x cPorts=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance,
    230230             Port, cPorts));
    231231
    232232    int rc = IOMR3IOPortDeregister(pDevIns->Internal.s.pVMR3, pDevIns, Port, cPorts);
    233233
    234     LogFlow(("pdmR3DevHlp_IOPortDeregister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     234    LogFlow(("pdmR3DevHlp_IOPortDeregister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    235235    return rc;
    236236}
     
    245245    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    246246    LogFlow(("pdmR3DevHlp_MMIORegister: caller='%s'/%d: GCPhysStart=%RGp cbRange=%#x pvUser=%p pfnWrite=%p pfnRead=%p pfnFill=%p pszDesc=%p:{%s}\n",
    247              pDevIns->pReg->szDeviceName, pDevIns->iInstance, GCPhysStart, cbRange, pvUser, pfnWrite, pfnRead, pfnFill, pszDesc, pszDesc));
     247             pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange, pvUser, pfnWrite, pfnRead, pfnFill, pszDesc, pszDesc));
    248248
    249249/** @todo IOMR3MMIORegisterR3 mangles the description, move it here. */
    250250    int rc = IOMR3MMIORegisterR3(pDevIns->Internal.s.pVMR3, pDevIns, GCPhysStart, cbRange, pvUser, pfnWrite, pfnRead, pfnFill, pszDesc);
    251251
    252     LogFlow(("pdmR3DevHlp_MMIORegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     252    LogFlow(("pdmR3DevHlp_MMIORegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    253253    return rc;
    254254}
     
    263263    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    264264    LogFlow(("pdmR3DevHlp_MMIORegisterRC: caller='%s'/%d: GCPhysStart=%RGp cbRange=%#x pvUser=%p pszWrite=%p:{%s} pszRead=%p:{%s} pszFill=%p:{%s}\n",
    265              pDevIns->pReg->szDeviceName, pDevIns->iInstance, GCPhysStart, cbRange, pvUser, pszWrite, pszWrite, pszRead, pszRead, pszFill, pszFill));
     265             pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange, pvUser, pszWrite, pszWrite, pszRead, pszRead, pszFill, pszFill));
    266266
    267267/** @todo pszDesc is unused here, drop it.  */
     
    308308    }
    309309
    310     LogFlow(("pdmR3DevHlp_MMIORegisterRC: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     310    LogFlow(("pdmR3DevHlp_MMIORegisterRC: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    311311    return rc;
    312312}
     
    320320    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    321321    LogFlow(("pdmR3DevHlp_MMIORegisterHC: caller='%s'/%d: GCPhysStart=%RGp cbRange=%#x pvUser=%p pszWrite=%p:{%s} pszRead=%p:{%s} pszFill=%p:{%s}\n",
    322              pDevIns->pReg->szDeviceName, pDevIns->iInstance, GCPhysStart, cbRange, pvUser, pszWrite, pszWrite, pszRead, pszRead, pszFill, pszFill));
     322             pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange, pvUser, pszWrite, pszWrite, pszRead, pszRead, pszFill, pszFill));
    323323
    324324/** @todo pszDesc is unused here, remove it.  */
     
    362362    }
    363363
    364     LogFlow(("pdmR3DevHlp_MMIORegisterR0: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     364    LogFlow(("pdmR3DevHlp_MMIORegisterR0: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    365365    return rc;
    366366}
     
    373373    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    374374    LogFlow(("pdmR3DevHlp_MMIODeregister: caller='%s'/%d: GCPhysStart=%RGp cbRange=%#x\n",
    375              pDevIns->pReg->szDeviceName, pDevIns->iInstance, GCPhysStart, cbRange));
     375             pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange));
    376376
    377377    int rc = IOMR3MMIODeregister(pDevIns->Internal.s.pVMR3, pDevIns, GCPhysStart, cbRange);
    378378
    379     LogFlow(("pdmR3DevHlp_MMIODeregister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     379    LogFlow(("pdmR3DevHlp_MMIODeregister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    380380    return rc;
    381381}
     
    390390    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    391391    LogFlow(("pdmR3DevHlp_MMIO2Register: caller='%s'/%d: iRegion=%#x cb=%#RGp fFlags=%RX32 ppv=%p pszDescp=%p:{%s}\n",
    392              pDevIns->pReg->szDeviceName, pDevIns->iInstance, iRegion, cb, fFlags, ppv, pszDesc, pszDesc));
     392             pDevIns->pReg->szName, pDevIns->iInstance, iRegion, cb, fFlags, ppv, pszDesc, pszDesc));
    393393
    394394/** @todo PGMR3PhysMMIO2Register mangles the description, move it here and
     
    396396    int rc = PGMR3PhysMMIO2Register(pDevIns->Internal.s.pVMR3, pDevIns, iRegion, cb, fFlags, ppv, pszDesc);
    397397
    398     LogFlow(("pdmR3DevHlp_MMIO2Register: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     398    LogFlow(("pdmR3DevHlp_MMIO2Register: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    399399    return rc;
    400400}
     
    409409    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    410410    LogFlow(("pdmR3DevHlp_MMIO2Deregister: caller='%s'/%d: iRegion=%#x\n",
    411              pDevIns->pReg->szDeviceName, pDevIns->iInstance, iRegion));
     411             pDevIns->pReg->szName, pDevIns->iInstance, iRegion));
    412412
    413413    AssertReturn(iRegion == UINT32_MAX, VERR_INVALID_PARAMETER);
     
    415415    int rc = PGMR3PhysMMIO2Deregister(pDevIns->Internal.s.pVMR3, pDevIns, iRegion);
    416416
    417     LogFlow(("pdmR3DevHlp_MMIO2Deregister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     417    LogFlow(("pdmR3DevHlp_MMIO2Deregister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    418418    return rc;
    419419}
     
    428428    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    429429    LogFlow(("pdmR3DevHlp_MMIO2Map: caller='%s'/%d: iRegion=%#x GCPhys=%#RGp\n",
    430              pDevIns->pReg->szDeviceName, pDevIns->iInstance, iRegion, GCPhys));
     430             pDevIns->pReg->szName, pDevIns->iInstance, iRegion, GCPhys));
    431431
    432432    int rc = PGMR3PhysMMIO2Map(pDevIns->Internal.s.pVMR3, pDevIns, iRegion, GCPhys);
    433433
    434     LogFlow(("pdmR3DevHlp_MMIO2Map: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     434    LogFlow(("pdmR3DevHlp_MMIO2Map: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    435435    return rc;
    436436}
     
    445445    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    446446    LogFlow(("pdmR3DevHlp_MMIO2Unmap: caller='%s'/%d: iRegion=%#x GCPhys=%#RGp\n",
    447              pDevIns->pReg->szDeviceName, pDevIns->iInstance, iRegion, GCPhys));
     447             pDevIns->pReg->szName, pDevIns->iInstance, iRegion, GCPhys));
    448448
    449449    int rc = PGMR3PhysMMIO2Unmap(pDevIns->Internal.s.pVMR3, pDevIns, iRegion, GCPhys);
    450450
    451     LogFlow(("pdmR3DevHlp_MMIO2Unmap: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     451    LogFlow(("pdmR3DevHlp_MMIO2Unmap: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    452452    return rc;
    453453}
     
    464464    VM_ASSERT_EMT(pVM);
    465465    LogFlow(("pdmR3DevHlp_MMHyperMapMMIO2: caller='%s'/%d: iRegion=%#x off=%RGp cb=%RGp pszDesc=%p:{%s} pRCPtr=%p\n",
    466              pDevIns->pReg->szDeviceName, pDevIns->iInstance, iRegion, off, cb, pszDesc, pszDesc, pRCPtr));
     466             pDevIns->pReg->szName, pDevIns->iInstance, iRegion, off, cb, pszDesc, pszDesc, pRCPtr));
    467467
    468468    if (pDevIns->iInstance > 0)
     
    475475    int rc = MMR3HyperMapMMIO2(pVM, pDevIns, iRegion, off, cb, pszDesc, pRCPtr);
    476476
    477     LogFlow(("pdmR3DevHlp_MMHyperMapMMIO2: caller='%s'/%d: returns %Rrc *pRCPtr=%RRv\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc, *pRCPtr));
     477    LogFlow(("pdmR3DevHlp_MMHyperMapMMIO2: caller='%s'/%d: returns %Rrc *pRCPtr=%RRv\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, *pRCPtr));
    478478    return rc;
    479479}
     
    490490    VM_ASSERT_EMT(pVM);
    491491    LogFlow(("pdmR3DevHlp_MMIO2MapKernel: caller='%s'/%d: iRegion=%#x off=%RGp cb=%RGp pszDesc=%p:{%s} pR0Ptr=%p\n",
    492              pDevIns->pReg->szDeviceName, pDevIns->iInstance, iRegion, off, cb, pszDesc, pszDesc, pR0Ptr));
     492             pDevIns->pReg->szName, pDevIns->iInstance, iRegion, off, cb, pszDesc, pszDesc, pR0Ptr));
    493493
    494494    if (pDevIns->iInstance > 0)
     
    501501    int rc = PGMR3PhysMMIO2MapKernel(pVM, pDevIns, iRegion, off, cb, pszDesc, pR0Ptr);
    502502
    503     LogFlow(("pdmR3DevHlp_MMIO2MapKernel: caller='%s'/%d: returns %Rrc *pR0Ptr=%RHv\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc, *pR0Ptr));
     503    LogFlow(("pdmR3DevHlp_MMIO2MapKernel: caller='%s'/%d: returns %Rrc *pR0Ptr=%RHv\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, *pR0Ptr));
    504504    return rc;
    505505}
     
    512512    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    513513    LogFlow(("pdmR3DevHlp_ROMRegister: caller='%s'/%d: GCPhysStart=%RGp cbRange=%#x pvBinary=%p fFlags=%#RX32 pszDesc=%p:{%s}\n",
    514              pDevIns->pReg->szDeviceName, pDevIns->iInstance, GCPhysStart, cbRange, pvBinary, fFlags, pszDesc, pszDesc));
     514             pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange, pvBinary, fFlags, pszDesc, pszDesc));
    515515
    516516/** @todo can we mangle pszDesc? */
    517517    int rc = PGMR3PhysRomRegister(pDevIns->Internal.s.pVMR3, pDevIns, GCPhysStart, cbRange, pvBinary, fFlags, pszDesc);
    518518
    519     LogFlow(("pdmR3DevHlp_ROMRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     519    LogFlow(("pdmR3DevHlp_ROMRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    520520    return rc;
    521521}
     
    527527    PDMDEV_ASSERT_DEVINS(pDevIns);
    528528    LogFlow(("pdmR3DevHlp_ROMProtectShadow: caller='%s'/%d: GCPhysStart=%RGp cbRange=%#x enmProt=%d\n",
    529              pDevIns->pReg->szDeviceName, pDevIns->iInstance, GCPhysStart, cbRange, enmProt));
     529             pDevIns->pReg->szName, pDevIns->iInstance, GCPhysStart, cbRange, enmProt));
    530530
    531531    int rc = PGMR3PhysRomProtect(pDevIns->Internal.s.pVMR3, GCPhysStart, cbRange, enmProt);
    532532
    533     LogFlow(("pdmR3DevHlp_ROMProtectShadow: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     533    LogFlow(("pdmR3DevHlp_ROMProtectShadow: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    534534    return rc;
    535535}
     
    546546    LogFlow(("pdmR3DevHlp_SSMRegister: caller='%s'/%d: uVersion=#x cbGuess=%#x pszBefore=%p:{%s}\n"
    547547             "    pfnLivePrep=%p pfnLiveExec=%p pfnLiveVote=%p pfnSavePrep=%p pfnSaveExec=%p pfnSaveDone=%p pszLoadPrep=%p pfnLoadExec=%p pfnLoadDone=%p\n",
    548              pDevIns->pReg->szDeviceName, pDevIns->iInstance, uVersion, cbGuess, pszBefore, pszBefore,
     548             pDevIns->pReg->szName, pDevIns->iInstance, uVersion, cbGuess, pszBefore, pszBefore,
    549549             pfnLivePrep, pfnLiveExec, pfnLiveVote,
    550550             pfnSavePrep, pfnSaveExec, pfnSaveDone,
    551551             pfnLoadPrep, pfnLoadExec, pfnLoadDone));
    552552
    553     int rc = SSMR3RegisterDevice(pDevIns->Internal.s.pVMR3, pDevIns, pDevIns->pReg->szDeviceName, pDevIns->iInstance,
     553    int rc = SSMR3RegisterDevice(pDevIns->Internal.s.pVMR3, pDevIns, pDevIns->pReg->szName, pDevIns->iInstance,
    554554                                 uVersion, cbGuess, pszBefore,
    555555                                 pfnLivePrep, pfnLiveExec, pfnLiveVote,
     
    557557                                 pfnLoadPrep, pfnLoadExec, pfnLoadDone);
    558558
    559     LogFlow(("pdmR3DevHlp_SSMRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     559    LogFlow(("pdmR3DevHlp_SSMRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    560560    return rc;
    561561}
     
    569569    VM_ASSERT_EMT(pVM);
    570570    LogFlow(("pdmR3DevHlp_TMTimerCreate: caller='%s'/%d: enmClock=%d pfnCallback=%p pvUser=%p fFlags=%#x pszDesc=%p:{%s} ppTimer=%p\n",
    571              pDevIns->pReg->szDeviceName, pDevIns->iInstance, enmClock, pfnCallback, pvUser, fFlags, pszDesc, pszDesc, ppTimer));
     571             pDevIns->pReg->szName, pDevIns->iInstance, enmClock, pfnCallback, pvUser, fFlags, pszDesc, pszDesc, ppTimer));
    572572
    573573    if (pDevIns->iInstance > 0) /** @todo use a string cache here later. */
     
    580580    int rc = TMR3TimerCreateDevice(pVM, pDevIns, enmClock, pfnCallback, pvUser, fFlags, pszDesc, ppTimer);
    581581
    582     LogFlow(("pdmR3DevHlp_TMTimerCreate: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     582    LogFlow(("pdmR3DevHlp_TMTimerCreate: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    583583    return rc;
    584584}
     
    590590    PDMDEV_ASSERT_DEVINS(pDevIns);
    591591    LogFlow(("pdmR3DevHlp_TMUtcNow: caller='%s'/%d: pTime=%p\n",
    592              pDevIns->pReg->szDeviceName, pDevIns->iInstance, pTime));
     592             pDevIns->pReg->szName, pDevIns->iInstance, pTime));
    593593
    594594    pTime = TMR3UtcNow(pDevIns->Internal.s.pVMR3, pTime);
    595595
    596     LogFlow(("pdmR3DevHlp_TMUtcNow: caller='%s'/%d: returns %RU64\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, RTTimeSpecGetNano(pTime)));
     596    LogFlow(("pdmR3DevHlp_TMUtcNow: caller='%s'/%d: returns %RU64\n", pDevIns->pReg->szName, pDevIns->iInstance, RTTimeSpecGetNano(pTime)));
    597597    return pTime;
    598598}
     
    605605    PVM pVM = pDevIns->Internal.s.pVMR3;
    606606    LogFlow(("pdmR3DevHlp_PhysRead: caller='%s'/%d: GCPhys=%RGp pvBuf=%p cbRead=%#x\n",
    607              pDevIns->pReg->szDeviceName, pDevIns->iInstance, GCPhys, pvBuf, cbRead));
     607             pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, pvBuf, cbRead));
    608608
    609609#if defined(VBOX_STRICT) && defined(PDM_DEVHLP_DEADLOCK_DETECTION)
     
    622622        rc = PGMR3PhysReadExternal(pVM, GCPhys, pvBuf, cbRead);
    623623
    624     Log(("pdmR3DevHlp_PhysRead: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     624    Log(("pdmR3DevHlp_PhysRead: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    625625    return rc;
    626626}
     
    633633    PVM pVM = pDevIns->Internal.s.pVMR3;
    634634    LogFlow(("pdmR3DevHlp_PhysWrite: caller='%s'/%d: GCPhys=%RGp pvBuf=%p cbWrite=%#x\n",
    635              pDevIns->pReg->szDeviceName, pDevIns->iInstance, GCPhys, pvBuf, cbWrite));
     635             pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, pvBuf, cbWrite));
    636636
    637637#if defined(VBOX_STRICT) && defined(PDM_DEVHLP_DEADLOCK_DETECTION)
     
    648648        rc = PGMPhysWrite(pVM, GCPhys, pvBuf, cbWrite);
    649649    else
    650         rc = PGMR3PhysWriteExternal(pVM, GCPhys, pvBuf, cbWrite, pDevIns->pReg->szDeviceName);
    651 
    652     Log(("pdmR3DevHlp_PhysWrite: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     650        rc = PGMR3PhysWriteExternal(pVM, GCPhys, pvBuf, cbWrite, pDevIns->pReg->szName);
     651
     652    Log(("pdmR3DevHlp_PhysWrite: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    653653    return rc;
    654654}
     
    661661    PVM pVM = pDevIns->Internal.s.pVMR3;
    662662    LogFlow(("pdmR3DevHlp_PhysGCPhys2CCPtr: caller='%s'/%d: GCPhys=%RGp fFlags=%#x ppv=%p pLock=%p\n",
    663              pDevIns->pReg->szDeviceName, pDevIns->iInstance, GCPhys, fFlags, ppv, pLock));
     663             pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, fFlags, ppv, pLock));
    664664    AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
    665665
     
    675675    int rc = PGMR3PhysGCPhys2CCPtrExternal(pVM, GCPhys, ppv, pLock);
    676676
    677     Log(("pdmR3DevHlp_PhysGCPhys2CCPtr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     677    Log(("pdmR3DevHlp_PhysGCPhys2CCPtr: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    678678    return rc;
    679679}
     
    686686    PVM pVM = pDevIns->Internal.s.pVMR3;
    687687    LogFlow(("pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly: caller='%s'/%d: GCPhys=%RGp fFlags=%#x ppv=%p pLock=%p\n",
    688              pDevIns->pReg->szDeviceName, pDevIns->iInstance, GCPhys, fFlags, ppv, pLock));
     688             pDevIns->pReg->szName, pDevIns->iInstance, GCPhys, fFlags, ppv, pLock));
    689689    AssertReturn(!fFlags, VERR_INVALID_PARAMETER);
    690690
     
    700700    int rc = PGMR3PhysGCPhys2CCPtrReadOnlyExternal(pVM, GCPhys, ppv, pLock);
    701701
    702     Log(("pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     702    Log(("pdmR3DevHlp_PhysGCPhys2CCPtrReadOnly: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    703703    return rc;
    704704}
     
    711711    PVM pVM = pDevIns->Internal.s.pVMR3;
    712712    LogFlow(("pdmR3DevHlp_PhysReleasePageMappingLock: caller='%s'/%d: pLock=%p\n",
    713              pDevIns->pReg->szDeviceName, pDevIns->iInstance, pLock));
     713             pDevIns->pReg->szName, pDevIns->iInstance, pLock));
    714714
    715715    PGMPhysReleasePageMappingLock(pVM, pLock);
    716716
    717     Log(("pdmR3DevHlp_PhysReleasePageMappingLock: caller='%s'/%d: returns void\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     717    Log(("pdmR3DevHlp_PhysReleasePageMappingLock: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
    718718}
    719719
     
    726726    VM_ASSERT_EMT(pVM);
    727727    LogFlow(("pdmR3DevHlp_PhysReadGCVirt: caller='%s'/%d: pvDst=%p GCVirt=%RGv cb=%#x\n",
    728              pDevIns->pReg->szDeviceName, pDevIns->iInstance, pvDst, GCVirtSrc, cb));
     728             pDevIns->pReg->szName, pDevIns->iInstance, pvDst, GCVirtSrc, cb));
    729729
    730730    PVMCPU pVCpu = VMMGetCpu(pVM);
     
    737737    int rc = PGMPhysSimpleReadGCPtr(pVCpu, pvDst, GCVirtSrc, cb);
    738738
    739     LogFlow(("pdmR3DevHlp_PhysReadGCVirt: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     739    LogFlow(("pdmR3DevHlp_PhysReadGCVirt: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    740740
    741741    return rc;
     
    750750    VM_ASSERT_EMT(pVM);
    751751    LogFlow(("pdmR3DevHlp_PhysWriteGCVirt: caller='%s'/%d: GCVirtDst=%RGv pvSrc=%p cb=%#x\n",
    752              pDevIns->pReg->szDeviceName, pDevIns->iInstance, GCVirtDst, pvSrc, cb));
     752             pDevIns->pReg->szName, pDevIns->iInstance, GCVirtDst, pvSrc, cb));
    753753
    754754    PVMCPU pVCpu = VMMGetCpu(pVM);
     
    761761    int rc = PGMPhysSimpleWriteGCPtr(pVCpu, GCVirtDst, pvSrc, cb);
    762762
    763     LogFlow(("pdmR3DevHlp_PhysWriteGCVirt: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     763    LogFlow(("pdmR3DevHlp_PhysWriteGCVirt: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    764764
    765765    return rc;
     
    774774    VM_ASSERT_EMT(pVM);
    775775    LogFlow(("pdmR3DevHlp_PhysGCPtr2GCPhys: caller='%s'/%d: GCPtr=%RGv pGCPhys=%p\n",
    776              pDevIns->pReg->szDeviceName, pDevIns->iInstance, GCPtr, pGCPhys));
     776             pDevIns->pReg->szName, pDevIns->iInstance, GCPtr, pGCPhys));
    777777
    778778    PVMCPU pVCpu = VMMGetCpu(pVM);
     
    785785    int rc = PGMPhysGCPtr2GCPhys(pVCpu, GCPtr, pGCPhys);
    786786
    787     LogFlow(("pdmR3DevHlp_PhysGCPtr2GCPhys: caller='%s'/%d: returns %Rrc *pGCPhys=%RGp\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc, *pGCPhys));
     787    LogFlow(("pdmR3DevHlp_PhysGCPtr2GCPhys: caller='%s'/%d: returns %Rrc *pGCPhys=%RGp\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, *pGCPhys));
    788788
    789789    return rc;
     
    795795{
    796796    PDMDEV_ASSERT_DEVINS(pDevIns);
    797     LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: cb=%#x\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, cb));
     797    LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: cb=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, cb));
    798798
    799799    void *pv = MMR3HeapAlloc(pDevIns->Internal.s.pVMR3, MM_TAG_PDM_DEVICE_USER, cb);
    800800
    801     LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: returns %p\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, pv));
     801    LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pv));
    802802    return pv;
    803803}
     
    808808{
    809809    PDMDEV_ASSERT_DEVINS(pDevIns);
    810     LogFlow(("pdmR3DevHlp_MMHeapAllocZ: caller='%s'/%d: cb=%#x\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, cb));
     810    LogFlow(("pdmR3DevHlp_MMHeapAllocZ: caller='%s'/%d: cb=%#x\n", pDevIns->pReg->szName, pDevIns->iInstance, cb));
    811811
    812812    void *pv = MMR3HeapAllocZ(pDevIns->Internal.s.pVMR3, MM_TAG_PDM_DEVICE_USER, cb);
    813813
    814     LogFlow(("pdmR3DevHlp_MMHeapAllocZ: caller='%s'/%d: returns %p\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, pv));
     814    LogFlow(("pdmR3DevHlp_MMHeapAllocZ: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pv));
    815815    return pv;
    816816}
     
    821821{
    822822    PDMDEV_ASSERT_DEVINS(pDevIns);
    823     LogFlow(("pdmR3DevHlp_MMHeapFree: caller='%s'/%d: pv=%p\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, pv));
     823    LogFlow(("pdmR3DevHlp_MMHeapFree: caller='%s'/%d: pv=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pv));
    824824
    825825    MMR3HeapFree(pv);
    826826
    827     LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: returns void\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     827    LogFlow(("pdmR3DevHlp_MMHeapAlloc: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
    828828}
    829829
     
    836836    VMSTATE enmVMState = VMR3GetState(pDevIns->Internal.s.pVMR3);
    837837
    838     LogFlow(("pdmR3DevHlp_VMState: caller='%s'/%d: returns %d (%s)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance,
     838    LogFlow(("pdmR3DevHlp_VMState: caller='%s'/%d: returns %d (%s)\n", pDevIns->pReg->szName, pDevIns->iInstance,
    839839             enmVMState, VMR3GetStateName(enmVMState)));
    840840    return enmVMState;
     
    849849    bool fRc = VMR3TeleportedAndNotFullyResumedYet(pDevIns->Internal.s.pVMR3);
    850850
    851     LogFlow(("pdmR3DevHlp_VMState: caller='%s'/%d: returns %RTbool\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance,
     851    LogFlow(("pdmR3DevHlp_VMState: caller='%s'/%d: returns %RTbool\n", pDevIns->pReg->szName, pDevIns->iInstance,
    852852             fRc));
    853853    return fRc;
     
    905905    va_copy(va2, args);
    906906    LogFlow(("pdmR3DevHlp_DBGFStopV: caller='%s'/%d: pszFile=%p:{%s} iLine=%d pszFunction=%p:{%s} pszFormat=%p:{%s} (%N)\n",
    907              pDevIns->pReg->szDeviceName, pDevIns->iInstance, pszFile, pszFile, iLine, pszFunction, pszFunction, pszFormat, pszFormat, pszFormat, &va2));
     907             pDevIns->pReg->szName, pDevIns->iInstance, pszFile, pszFile, iLine, pszFunction, pszFunction, pszFormat, pszFormat, pszFormat, &va2));
    908908    va_end(va2);
    909909#endif
     
    915915        rc = VINF_SUCCESS;
    916916
    917     LogFlow(("pdmR3DevHlp_DBGFStopV: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     917    LogFlow(("pdmR3DevHlp_DBGFStopV: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    918918    return rc;
    919919}
     
    925925    PDMDEV_ASSERT_DEVINS(pDevIns);
    926926    LogFlow(("pdmR3DevHlp_DBGFInfoRegister: caller='%s'/%d: pszName=%p:{%s} pszDesc=%p:{%s} pfnHandler=%p\n",
    927              pDevIns->pReg->szDeviceName, pDevIns->iInstance, pszName, pszName, pszDesc, pszDesc, pfnHandler));
     927             pDevIns->pReg->szName, pDevIns->iInstance, pszName, pszName, pszDesc, pszDesc, pfnHandler));
    928928
    929929    PVM pVM = pDevIns->Internal.s.pVMR3;
     
    931931    int rc = DBGFR3InfoRegisterDevice(pVM, pszName, pszDesc, pfnHandler, pDevIns);
    932932
    933     LogFlow(("pdmR3DevHlp_DBGFInfoRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     933    LogFlow(("pdmR3DevHlp_DBGFInfoRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    934934    return rc;
    935935}
     
    989989    VM_ASSERT_EMT(pVM);
    990990    LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: pPciDev=%p:{.config={%#.256Rhxs}\n",
    991              pDevIns->pReg->szDeviceName, pDevIns->iInstance, pPciDev, pPciDev->config));
     991             pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pPciDev->config));
    992992
    993993    /*
     
    997997    {
    998998        Assert(pPciDev);
    999         LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc (pPciDev)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     999        LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc (pPciDev)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    10001000        return VERR_INVALID_PARAMETER;
    10011001    }
     
    10031003    {
    10041004        Assert(pPciDev->config[0] || pPciDev->config[1]);
    1005         LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc (vendor)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     1005        LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc (vendor)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    10061006        return VERR_INVALID_PARAMETER;
    10071007    }
     
    10301030        rc = CFGMR3QueryU8Def(pDevIns->Internal.s.pCfgHandle, "PCIBusNo", &u8Bus, 0);
    10311031        AssertLogRelMsgRCReturn(rc, ("Configuration error: PCIBusNo query failed with rc=%Rrc (%s/%d)\n",
    1032                                      rc, pDevIns->pReg->szDeviceName, pDevIns->iInstance), rc);
     1032                                     rc, pDevIns->pReg->szName, pDevIns->iInstance), rc);
    10331033        AssertLogRelMsgReturn(u8Bus < RT_ELEMENTS(pVM->pdm.s.aPciBuses),
    10341034                              ("Configuration error: PCIBusNo=%d, max is %d. (%s/%d)\n", u8Bus,
    1035                                RT_ELEMENTS(pVM->pdm.s.aPciBuses), pDevIns->pReg->szDeviceName, pDevIns->iInstance),
     1035                               RT_ELEMENTS(pVM->pdm.s.aPciBuses), pDevIns->pReg->szName, pDevIns->iInstance),
    10361036                              VERR_PDM_NO_PCI_BUS);
    10371037        pBus = pDevIns->Internal.s.pPciBusR3 = &pVM->pdm.s.aPciBuses[u8Bus];
     
    10601060            {
    10611061                AssertMsgFailed(("Configuration error: PCIDeviceNo=%d, max is 31. (%s/%d)\n",
    1062                                  u8Device, pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     1062                                 u8Device, pDevIns->pReg->szName, pDevIns->iInstance));
    10631063                return VERR_INTERNAL_ERROR;
    10641064            }
     
    10691069            {
    10701070                AssertMsgFailed(("Configuration error: PCIDeviceNo, but PCIFunctionNo query failed with rc=%Rrc (%s/%d)\n",
    1071                                  rc, pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     1071                                 rc, pDevIns->pReg->szName, pDevIns->iInstance));
    10721072                return rc;
    10731073            }
     
    10751075            {
    10761076                AssertMsgFailed(("Configuration error: PCIFunctionNo=%d, max is 7. (%s/%d)\n",
    1077                                  u8Function, pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     1077                                 u8Function, pDevIns->pReg->szName, pDevIns->iInstance));
    10781078                return VERR_INTERNAL_ERROR;
    10791079            }
     
    10831083        {
    10841084            AssertMsgFailed(("Configuration error: PCIDeviceNo query failed with rc=%Rrc (%s/%d)\n",
    1085                              rc, pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     1085                             rc, pDevIns->pReg->szName, pDevIns->iInstance));
    10861086            return rc;
    10871087        }
     
    10911091         */
    10921092        pdmLock(pVM);
    1093         rc = pBus->pfnRegisterR3(pBus->pDevInsR3, pPciDev, pDevIns->pReg->szDeviceName, iDev);
     1093        rc = pBus->pfnRegisterR3(pBus->pDevInsR3, pPciDev, pDevIns->pReg->szName, iDev);
    10941094        pdmUnlock(pVM);
    10951095        if (RT_SUCCESS(rc))
     
    11091109
    11101110            Log(("PDM: Registered device '%s'/%d as PCI device %d on bus %d\n",
    1111                  pDevIns->pReg->szDeviceName, pDevIns->iInstance, pPciDev->devfn, pDevIns->Internal.s.pPciBusR3->iBus));
     1111                 pDevIns->pReg->szName, pDevIns->iInstance, pPciDev->devfn, pDevIns->Internal.s.pPciBusR3->iBus));
    11121112        }
    11131113    }
     
    11181118    }
    11191119
    1120     LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     1120    LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    11211121    return rc;
    11221122}
     
    11301130    VM_ASSERT_EMT(pVM);
    11311131    LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: iRegion=%d cbRegion=%#x enmType=%d pfnCallback=%p\n",
    1132              pDevIns->pReg->szDeviceName, pDevIns->iInstance, iRegion, cbRegion, enmType, pfnCallback));
     1132             pDevIns->pReg->szName, pDevIns->iInstance, iRegion, cbRegion, enmType, pfnCallback));
    11331133
    11341134    /*
     
    11381138    {
    11391139        Assert(iRegion >= 0 && iRegion < PCI_NUM_REGIONS);
    1140         LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc (iRegion)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     1140        LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc (iRegion)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    11411141        return VERR_INVALID_PARAMETER;
    11421142    }
     
    11481148             */
    11491149            AssertMsgReturn(cbRegion <= _32K,
    1150                             ("caller='%s'/%d: %#x\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, cbRegion),
     1150                            ("caller='%s'/%d: %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, cbRegion),
    11511151                            VERR_INVALID_PARAMETER);
    11521152            break;
     
    11591159             */
    11601160            AssertMsgReturn(cbRegion <= 512 * _1M,
    1161                             ("caller='%s'/%d: %#x\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, cbRegion),
     1161                            ("caller='%s'/%d: %#x\n", pDevIns->pReg->szName, pDevIns->iInstance, cbRegion),
    11621162                            VERR_INVALID_PARAMETER);
    11631163            break;
    11641164        default:
    11651165            AssertMsgFailed(("enmType=%#x is unknown\n", enmType));
    1166             LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc (enmType)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     1166            LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc (enmType)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    11671167            return VERR_INVALID_PARAMETER;
    11681168    }
     
    11701170    {
    11711171        Assert(pfnCallback);
    1172         LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc (callback)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     1172        LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc (callback)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    11731173        return VERR_INVALID_PARAMETER;
    11741174    }
     
    11891189        {
    11901190            Log(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: aligning cbRegion %#x -> %#x\n",
    1191                  pDevIns->pReg->szDeviceName, pDevIns->iInstance, cbRegion, RT_ALIGN_32(cbRegion, PAGE_SIZE)));
     1191                 pDevIns->pReg->szName, pDevIns->iInstance, cbRegion, RT_ALIGN_32(cbRegion, PAGE_SIZE)));
    11921192            cbRegion = RT_ALIGN_32(cbRegion, PAGE_SIZE);
    11931193        }
     
    12141214    }
    12151215
    1216     LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     1216    LogFlow(("pdmR3DevHlp_PCIIORegionRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    12171217    return rc;
    12181218}
     
    12271227    VM_ASSERT_EMT(pVM);
    12281228    LogFlow(("pdmR3DevHlp_PCISetConfigCallbacks: caller='%s'/%d: pPciDev=%p pfnRead=%p ppfnReadOld=%p pfnWrite=%p ppfnWriteOld=%p\n",
    1229              pDevIns->pReg->szDeviceName, pDevIns->iInstance, pPciDev, pfnRead, ppfnReadOld, pfnWrite, ppfnWriteOld));
     1229             pDevIns->pReg->szName, pDevIns->iInstance, pPciDev, pfnRead, ppfnReadOld, pfnWrite, ppfnWriteOld));
    12301230
    12311231    /*
     
    12521252    pdmUnlock(pVM);
    12531253
    1254     LogFlow(("pdmR3DevHlp_PCISetConfigCallbacks: caller='%s'/%d: returns void\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     1254    LogFlow(("pdmR3DevHlp_PCISetConfigCallbacks: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
    12551255}
    12561256
     
    12601260{
    12611261    PDMDEV_ASSERT_DEVINS(pDevIns);
    1262     LogFlow(("pdmR3DevHlp_PCISetIrq: caller='%s'/%d: iIrq=%d iLevel=%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, iIrq, iLevel));
     1262    LogFlow(("pdmR3DevHlp_PCISetIrq: caller='%s'/%d: iIrq=%d iLevel=%d\n", pDevIns->pReg->szName, pDevIns->iInstance, iIrq, iLevel));
    12631263
    12641264    /*
     
    12831283        AssertReleaseMsgFailed(("No PCI device registered!\n"));
    12841284
    1285     LogFlow(("pdmR3DevHlp_PCISetIrq: caller='%s'/%d: returns void\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     1285    LogFlow(("pdmR3DevHlp_PCISetIrq: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
    12861286}
    12871287
     
    12981298{
    12991299    PDMDEV_ASSERT_DEVINS(pDevIns);
    1300     LogFlow(("pdmR3DevHlp_ISASetIrq: caller='%s'/%d: iIrq=%d iLevel=%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, iIrq, iLevel));
     1300    LogFlow(("pdmR3DevHlp_ISASetIrq: caller='%s'/%d: iIrq=%d iLevel=%d\n", pDevIns->pReg->szName, pDevIns->iInstance, iIrq, iLevel));
    13011301
    13021302    /*
     
    13081308    PDMIsaSetIrq(pVM, iIrq, iLevel);    /* (The API takes the lock.) */
    13091309
    1310     LogFlow(("pdmR3DevHlp_ISASetIrq: caller='%s'/%d: returns void\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     1310    LogFlow(("pdmR3DevHlp_ISASetIrq: caller='%s'/%d: returns void\n", pDevIns->pReg->szName, pDevIns->iInstance));
    13111311}
    13121312
     
    13261326    VM_ASSERT_EMT(pVM);
    13271327    LogFlow(("pdmR3DevHlp_DriverAttach: caller='%s'/%d: iLun=%d pBaseInterface=%p ppBaseInterface=%p pszDesc=%p:{%s}\n",
    1328              pDevIns->pReg->szDeviceName, pDevIns->iInstance, iLun, pBaseInterface, ppBaseInterface, pszDesc, pszDesc));
     1328             pDevIns->pReg->szName, pDevIns->iInstance, iLun, pBaseInterface, ppBaseInterface, pszDesc, pszDesc));
    13291329
    13301330    /*
     
    13681368            pLunPrev->pNext = pLun;
    13691369        Log(("pdmR3DevHlp_DriverAttach: Registered LUN#%d '%s' with device '%s'/%d.\n",
    1370              iLun, pszDesc, pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     1370             iLun, pszDesc, pDevIns->pReg->szName, pDevIns->iInstance));
    13711371    }
    13721372    else if (pLun->pTop)
    13731373    {
    13741374        AssertMsgFailed(("Already attached! The device should keep track of such things!\n"));
    1375         LogFlow(("pdmR3DevHlp_DriverAttach: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_PDM_DRIVER_ALREADY_ATTACHED));
     1375        LogFlow(("pdmR3DevHlp_DriverAttach: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_PDM_DRIVER_ALREADY_ATTACHED));
    13761376        return VERR_PDM_DRIVER_ALREADY_ATTACHED;
    13771377    }
     
    13901390
    13911391
    1392     LogFlow(("pdmR3DevHlp_DriverAttach: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     1392    LogFlow(("pdmR3DevHlp_DriverAttach: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    13931393    return rc;
    13941394}
     
    14011401    PDMDEV_ASSERT_DEVINS(pDevIns);
    14021402    LogFlow(("pdmR3DevHlp_QueueCreate: caller='%s'/%d: cbItem=%#x cItems=%#x cMilliesInterval=%u pfnCallback=%p fGCEnabled=%RTbool pszName=%p:{%s} ppQueue=%p\n",
    1403              pDevIns->pReg->szDeviceName, pDevIns->iInstance, cbItem, cItems, cMilliesInterval, pfnCallback, fGCEnabled, pszName, pszName, ppQueue));
     1403             pDevIns->pReg->szName, pDevIns->iInstance, cbItem, cItems, cMilliesInterval, pfnCallback, fGCEnabled, pszName, pszName, ppQueue));
    14041404
    14051405    PVM pVM = pDevIns->Internal.s.pVMR3;
     
    14141414    int rc = PDMR3QueueCreateDevice(pVM, pDevIns, cbItem, cItems, cMilliesInterval, pfnCallback, fGCEnabled, pszName, ppQueue);
    14151415
    1416     LogFlow(("pdmR3DevHlp_QueueCreate: caller='%s'/%d: returns %Rrc *ppQueue=%p\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc, *ppQueue));
     1416    LogFlow(("pdmR3DevHlp_QueueCreate: caller='%s'/%d: returns %Rrc *ppQueue=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, rc, *ppQueue));
    14171417    return rc;
    14181418}
     
    14251425    PDMDEV_ASSERT_DEVINS(pDevIns);
    14261426    LogFlow(("pdmR3DevHlp_CritSectInit: caller='%s'/%d: pCritSect=%p pszNameFmt=%p:{%s}\n",
    1427              pDevIns->pReg->szDeviceName, pDevIns->iInstance, pCritSect, pszNameFmt, pszNameFmt));
     1427             pDevIns->pReg->szName, pDevIns->iInstance, pCritSect, pszNameFmt, pszNameFmt));
    14281428
    14291429    PVM pVM = pDevIns->Internal.s.pVMR3;
     
    14311431    int rc = pdmR3CritSectInitDevice(pVM, pDevIns, pCritSect, RT_SRC_POS, pszNameFmt, va);
    14321432
    1433     LogFlow(("pdmR3DevHlp_CritSectInit: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     1433    LogFlow(("pdmR3DevHlp_CritSectInit: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    14341434    return rc;
    14351435}
     
    14431443    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    14441444    LogFlow(("pdmR3DevHlp_ThreadCreate: caller='%s'/%d: ppThread=%p pvUser=%p pfnThread=%p pfnWakeup=%p cbStack=%#zx enmType=%d pszName=%p:{%s}\n",
    1445              pDevIns->pReg->szDeviceName, pDevIns->iInstance, ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName, pszName));
     1445             pDevIns->pReg->szName, pDevIns->iInstance, ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName, pszName));
    14461446
    14471447    int rc = pdmR3ThreadCreateDevice(pDevIns->Internal.s.pVMR3, pDevIns, ppThread, pvUser, pfnThread, pfnWakeup, cbStack, enmType, pszName);
    14481448
    1449     LogFlow(("pdmR3DevHlp_ThreadCreate: caller='%s'/%d: returns %Rrc *ppThread=%RTthrd\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance,
     1449    LogFlow(("pdmR3DevHlp_ThreadCreate: caller='%s'/%d: returns %Rrc *ppThread=%RTthrd\n", pDevIns->pReg->szName, pDevIns->iInstance,
    14501450            rc, *ppThread));
    14511451    return rc;
     
    14581458    PDMDEV_ASSERT_DEVINS(pDevIns);
    14591459    VM_ASSERT_EMT0(pDevIns->Internal.s.pVMR3);
    1460     LogFlow(("pdmR3DevHlp_SetAsyncNotification: caller='%s'/%d: pfnAsyncNotify=%p\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, pfnAsyncNotify));
     1460    LogFlow(("pdmR3DevHlp_SetAsyncNotification: caller='%s'/%d: pfnAsyncNotify=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pfnAsyncNotify));
    14611461
    14621462    int rc = VINF_SUCCESS;
     
    14771477        pDevIns->Internal.s.pfnAsyncNotify = pfnAsyncNotify;
    14781478
    1479     LogFlow(("pdmR3DevHlp_SetAsyncNotification: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     1479    LogFlow(("pdmR3DevHlp_SetAsyncNotification: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    14801480    return rc;
    14811481}
     
    14971497        || enmVMState == VMSTATE_POWERING_OFF_LS)
    14981498    {
    1499         LogFlow(("pdmR3DevHlp_AsyncNotificationCompleted: caller='%s'/%d:\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     1499        LogFlow(("pdmR3DevHlp_AsyncNotificationCompleted: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
    15001500        VMR3AsyncPdmNotificationWakeupU(pVM->pUVM);
    15011501    }
    15021502    else
    1503         LogFlow(("pdmR3DevHlp_AsyncNotificationCompleted: caller='%s'/%d: enmVMState=%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, enmVMState));
     1503        LogFlow(("pdmR3DevHlp_AsyncNotificationCompleted: caller='%s'/%d: enmVMState=%d\n", pDevIns->pReg->szName, pDevIns->iInstance, enmVMState));
    15041504}
    15051505
     
    15111511    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    15121512    LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: pRtcReg=%p:{.u32Version=%#x, .pfnWrite=%p, .pfnRead=%p} ppRtcHlp=%p\n",
    1513              pDevIns->pReg->szDeviceName, pDevIns->iInstance, pRtcReg, pRtcReg->u32Version, pRtcReg->pfnWrite,
     1513             pDevIns->pReg->szName, pDevIns->iInstance, pRtcReg, pRtcReg->u32Version, pRtcReg->pfnWrite,
    15141514             pRtcReg->pfnWrite, ppRtcHlp));
    15151515
     
    15221522                         PDM_RTCREG_VERSION));
    15231523        LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc (version)\n",
    1524                  pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     1524                 pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    15251525        return VERR_INVALID_PARAMETER;
    15261526    }
     
    15311531        Assert(pRtcReg->pfnRead);
    15321532        LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc (callbacks)\n",
    1533                  pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     1533                 pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    15341534        return VERR_INVALID_PARAMETER;
    15351535    }
     
    15391539        Assert(ppRtcHlp);
    15401540        LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc (ppRtcHlp)\n",
    1541                  pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     1541                 pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    15421542        return VERR_INVALID_PARAMETER;
    15431543    }
     
    15511551        AssertMsgFailed(("Only one RTC device is supported!\n"));
    15521552        LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc\n",
    1553                  pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     1553                 pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    15541554        return VERR_INVALID_PARAMETER;
    15551555    }
     
    15691569        *ppRtcHlp = &g_pdmR3DevRtcHlp;
    15701570        Log(("PDM: Registered RTC device '%s'/%d pDevIns=%p\n",
    1571              pDevIns->pReg->szDeviceName, pDevIns->iInstance, pDevIns));
     1571             pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
    15721572    }
    15731573    else
     
    15751575
    15761576    LogFlow(("pdmR3DevHlp_RTCRegister: caller='%s'/%d: returns %Rrc\n",
    1577              pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     1577             pDevIns->pReg->szName, pDevIns->iInstance, rc));
    15781578    return rc;
    15791579}
     
    15871587    VM_ASSERT_EMT(pVM);
    15881588    LogFlow(("pdmR3DevHlp_DMARegister: caller='%s'/%d: uChannel=%d pfnTransferHandler=%p pvUser=%p\n",
    1589              pDevIns->pReg->szDeviceName, pDevIns->iInstance, uChannel, pfnTransferHandler, pvUser));
     1589             pDevIns->pReg->szName, pDevIns->iInstance, uChannel, pfnTransferHandler, pvUser));
    15901590    int rc = VINF_SUCCESS;
    15911591    if (pVM->pdm.s.pDmac)
     
    15971597    }
    15981598    LogFlow(("pdmR3DevHlp_DMARegister: caller='%s'/%d: returns %Rrc\n",
    1599              pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     1599             pDevIns->pReg->szName, pDevIns->iInstance, rc));
    16001600    return rc;
    16011601}
     
    16091609    VM_ASSERT_EMT(pVM);
    16101610    LogFlow(("pdmR3DevHlp_DMAReadMemory: caller='%s'/%d: uChannel=%d pvBuffer=%p off=%#x cbBlock=%#x pcbRead=%p\n",
    1611              pDevIns->pReg->szDeviceName, pDevIns->iInstance, uChannel, pvBuffer, off, cbBlock, pcbRead));
     1611             pDevIns->pReg->szName, pDevIns->iInstance, uChannel, pvBuffer, off, cbBlock, pcbRead));
    16121612    int rc = VINF_SUCCESS;
    16131613    if (pVM->pdm.s.pDmac)
     
    16231623    }
    16241624    LogFlow(("pdmR3DevHlp_DMAReadMemory: caller='%s'/%d: returns %Rrc\n",
    1625              pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     1625             pDevIns->pReg->szName, pDevIns->iInstance, rc));
    16261626    return rc;
    16271627}
     
    16351635    VM_ASSERT_EMT(pVM);
    16361636    LogFlow(("pdmR3DevHlp_DMAWriteMemory: caller='%s'/%d: uChannel=%d pvBuffer=%p off=%#x cbBlock=%#x pcbWritten=%p\n",
    1637              pDevIns->pReg->szDeviceName, pDevIns->iInstance, uChannel, pvBuffer, off, cbBlock, pcbWritten));
     1637             pDevIns->pReg->szName, pDevIns->iInstance, uChannel, pvBuffer, off, cbBlock, pcbWritten));
    16381638    int rc = VINF_SUCCESS;
    16391639    if (pVM->pdm.s.pDmac)
     
    16491649    }
    16501650    LogFlow(("pdmR3DevHlp_DMAWriteMemory: caller='%s'/%d: returns %Rrc\n",
    1651              pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     1651             pDevIns->pReg->szName, pDevIns->iInstance, rc));
    16521652    return rc;
    16531653}
     
    16611661    VM_ASSERT_EMT(pVM);
    16621662    LogFlow(("pdmR3DevHlp_DMASetDREQ: caller='%s'/%d: uChannel=%d uLevel=%d\n",
    1663              pDevIns->pReg->szDeviceName, pDevIns->iInstance, uChannel, uLevel));
     1663             pDevIns->pReg->szName, pDevIns->iInstance, uChannel, uLevel));
    16641664    int rc = VINF_SUCCESS;
    16651665    if (pVM->pdm.s.pDmac)
     
    16711671    }
    16721672    LogFlow(("pdmR3DevHlp_DMASetDREQ: caller='%s'/%d: returns %Rrc\n",
    1673              pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     1673             pDevIns->pReg->szName, pDevIns->iInstance, rc));
    16741674    return rc;
    16751675}
     
    16821682    VM_ASSERT_EMT(pVM);
    16831683    LogFlow(("pdmR3DevHlp_DMAGetChannelMode: caller='%s'/%d: uChannel=%d\n",
    1684              pDevIns->pReg->szDeviceName, pDevIns->iInstance, uChannel));
     1684             pDevIns->pReg->szName, pDevIns->iInstance, uChannel));
    16851685    uint8_t u8Mode;
    16861686    if (pVM->pdm.s.pDmac)
     
    16921692    }
    16931693    LogFlow(("pdmR3DevHlp_DMAGetChannelMode: caller='%s'/%d: returns %#04x\n",
    1694              pDevIns->pReg->szDeviceName, pDevIns->iInstance, u8Mode));
     1694             pDevIns->pReg->szName, pDevIns->iInstance, u8Mode));
    16951695    return u8Mode;
    16961696}
     
    17031703    VM_ASSERT_EMT(pVM);
    17041704    LogFlow(("pdmR3DevHlp_DMASchedule: caller='%s'/%d: VM_FF_PDM_DMA %d -> 1\n",
    1705              pDevIns->pReg->szDeviceName, pDevIns->iInstance, VM_FF_ISSET(pVM, VM_FF_PDM_DMA)));
     1705             pDevIns->pReg->szName, pDevIns->iInstance, VM_FF_ISSET(pVM, VM_FF_PDM_DMA)));
    17061706
    17071707    AssertMsg(pVM->pdm.s.pDmac, ("Configuration error: No DMAC controller available. This could be related to init order too!\n"));
     
    17201720
    17211721    LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: iReg=%#04x u8Value=%#04x\n",
    1722              pDevIns->pReg->szDeviceName, pDevIns->iInstance, iReg, u8Value));
     1722             pDevIns->pReg->szName, pDevIns->iInstance, iReg, u8Value));
    17231723    int rc;
    17241724    if (pVM->pdm.s.pRtc)
     
    17281728
    17291729    LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: return %Rrc\n",
    1730              pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     1730             pDevIns->pReg->szName, pDevIns->iInstance, rc));
    17311731    return rc;
    17321732}
     
    17411741
    17421742    LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: iReg=%#04x pu8Value=%p\n",
    1743              pDevIns->pReg->szDeviceName, pDevIns->iInstance, iReg, pu8Value));
     1743             pDevIns->pReg->szName, pDevIns->iInstance, iReg, pu8Value));
    17441744    int rc;
    17451745    if (pVM->pdm.s.pRtc)
     
    17491749
    17501750    LogFlow(("pdmR3DevHlp_CMOSWrite: caller='%s'/%d: return %Rrc\n",
    1751              pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     1751             pDevIns->pReg->szName, pDevIns->iInstance, rc));
    17521752    return rc;
    17531753}
     
    17621762
    17631763    char szMsg[100];
    1764     RTStrPrintf(szMsg, sizeof(szMsg), "AssertEMT '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance);
     1764    RTStrPrintf(szMsg, sizeof(szMsg), "AssertEMT '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance);
    17651765    RTAssertMsg1Weak(szMsg, iLine, pszFile, pszFunction);
    17661766    AssertBreakpoint();
     
    17771777
    17781778    char szMsg[100];
    1779     RTStrPrintf(szMsg, sizeof(szMsg), "AssertOther '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance);
     1779    RTStrPrintf(szMsg, sizeof(szMsg), "AssertOther '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance);
    17801780    RTAssertMsg1Weak(szMsg, iLine, pszFile, pszFunction);
    17811781    AssertBreakpoint();
     
    17911791    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    17921792    LogFlow(("pdmR3DevHlp_PDMLdrGetRCInterfaceSymbols: caller='%s'/%d: pvInterface=%p cbInterface=%zu pszSymPrefix=%p:{%s} pszSymList=%p:{%s}\n",
    1793              pDevIns->pReg->szDeviceName, pDevIns->iInstance, pvInterface, cbInterface, pszSymPrefix, pszSymPrefix, pszSymList, pszSymList));
     1793             pDevIns->pReg->szName, pDevIns->iInstance, pvInterface, cbInterface, pszSymPrefix, pszSymPrefix, pszSymList, pszSymList));
    17941794
    17951795    int rc;
    17961796    if (   strncmp(pszSymPrefix, "dev", 3) == 0
    1797         && RTStrIStr(pszSymPrefix + 3, pDevIns->pReg->szDeviceName) != NULL)
     1797        && RTStrIStr(pszSymPrefix + 3, pDevIns->pReg->szName) != NULL)
    17981798    {
    17991799        if (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC)
    18001800            rc = PDMR3LdrGetInterfaceSymbols(pDevIns->Internal.s.pVMR3, pvInterface, cbInterface,
    1801                                              pDevIns->pReg->szDeviceName, pszSymPrefix, pszSymList,
     1801                                             pDevIns->pReg->szName, pszSymPrefix, pszSymList,
    18021802                                             false /*fRing0OrRC*/);
    18031803        else
     
    18101810    {
    18111811        AssertMsgFailed(("Invalid prefix '%s' for '%s'; must start with 'dev' and contain the driver name!\n",
    1812                          pszSymPrefix, pDevIns->pReg->szDeviceName));
     1812                         pszSymPrefix, pDevIns->pReg->szName));
    18131813        rc = VERR_INVALID_NAME;
    18141814    }
    18151815
    1816     LogFlow(("pdmR3DevHlp_PDMLdrGetRCInterfaceSymbols: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName,
     1816    LogFlow(("pdmR3DevHlp_PDMLdrGetRCInterfaceSymbols: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName,
    18171817             pDevIns->iInstance, rc));
    18181818    return rc;
     
    18271827    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    18281828    LogFlow(("pdmR3DevHlp_PDMLdrGetR0InterfaceSymbols: caller='%s'/%d: pvInterface=%p cbInterface=%zu pszSymPrefix=%p:{%s} pszSymList=%p:{%s}\n",
    1829              pDevIns->pReg->szDeviceName, pDevIns->iInstance, pvInterface, cbInterface, pszSymPrefix, pszSymPrefix, pszSymList, pszSymList));
     1829             pDevIns->pReg->szName, pDevIns->iInstance, pvInterface, cbInterface, pszSymPrefix, pszSymPrefix, pszSymList, pszSymList));
    18301830
    18311831    int rc;
    18321832    if (   strncmp(pszSymPrefix, "dev", 3) == 0
    1833         && RTStrIStr(pszSymPrefix + 3, pDevIns->pReg->szDeviceName) != NULL)
     1833        && RTStrIStr(pszSymPrefix + 3, pDevIns->pReg->szName) != NULL)
    18341834    {
    18351835        if (pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_R0)
    18361836            rc = PDMR3LdrGetInterfaceSymbols(pDevIns->Internal.s.pVMR3, pvInterface, cbInterface,
    1837                                              pDevIns->pReg->szDeviceName, pszSymPrefix, pszSymList,
     1837                                             pDevIns->pReg->szName, pszSymPrefix, pszSymList,
    18381838                                             true /*fRing0OrRC*/);
    18391839        else
     
    18461846    {
    18471847        AssertMsgFailed(("Invalid prefix '%s' for '%s'; must start with 'dev' and contain the driver name!\n",
    1848                          pszSymPrefix, pDevIns->pReg->szDeviceName));
     1848                         pszSymPrefix, pDevIns->pReg->szName));
    18491849        rc = VERR_INVALID_NAME;
    18501850    }
    18511851
    1852     LogFlow(("pdmR3DevHlp_PDMLdrGetR0InterfaceSymbols: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName,
     1852    LogFlow(("pdmR3DevHlp_PDMLdrGetR0InterfaceSymbols: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName,
    18531853             pDevIns->iInstance, rc));
    18541854    return rc;
     
    18601860{
    18611861    PDMDEV_ASSERT_DEVINS(pDevIns);
    1862     LogFlow(("pdmR3DevHlp_GetVM: caller='%s'/%d: returns %p\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, pDevIns->Internal.s.pVMR3));
     1862    LogFlow(("pdmR3DevHlp_GetVM: caller='%s'/%d: returns %p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns->Internal.s.pVMR3));
    18631863    return pDevIns->Internal.s.pVMR3;
    18641864}
     
    18701870    PDMDEV_ASSERT_DEVINS(pDevIns);
    18711871    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    1872     LogFlow(("pdmR3DevHlp_GetVMCPU: caller='%s'/%d for CPU %u\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VMMGetCpuId(pDevIns->Internal.s.pVMR3)));
     1872    LogFlow(("pdmR3DevHlp_GetVMCPU: caller='%s'/%d for CPU %u\n", pDevIns->pReg->szName, pDevIns->iInstance, VMMGetCpuId(pDevIns->Internal.s.pVMR3)));
    18731873    return VMMGetCpu(pDevIns->Internal.s.pVMR3);
    18741874}
     
    18831883    LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: pPciBusReg=%p:{.u32Version=%#x, .pfnRegisterR3=%p, .pfnIORegionRegisterR3=%p, .pfnSetIrqR3=%p, "
    18841884             ".pfnSaveExecR3=%p, .pfnLoadExecR3=%p, .pfnFakePCIBIOSR3=%p, .pszSetIrqRC=%p:{%s}, .pszSetIrqR0=%p:{%s}} ppPciHlpR3=%p\n",
    1885              pDevIns->pReg->szDeviceName, pDevIns->iInstance, pPciBusReg, pPciBusReg->u32Version, pPciBusReg->pfnRegisterR3,
     1885             pDevIns->pReg->szName, pDevIns->iInstance, pPciBusReg, pPciBusReg->u32Version, pPciBusReg->pfnRegisterR3,
    18861886             pPciBusReg->pfnIORegionRegisterR3, pPciBusReg->pfnSetIrqR3, pPciBusReg->pfnSaveExecR3, pPciBusReg->pfnLoadExecR3,
    18871887             pPciBusReg->pfnFakePCIBIOSR3, pPciBusReg->pszSetIrqRC, pPciBusReg->pszSetIrqRC, pPciBusReg->pszSetIrqR0, pPciBusReg->pszSetIrqR0, ppPciHlpR3));
     
    18931893    {
    18941894        AssertMsgFailed(("u32Version=%#x expected %#x\n", pPciBusReg->u32Version, PDM_PCIBUSREG_VERSION));
    1895         LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     1895        LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    18961896        return VERR_INVALID_PARAMETER;
    18971897    }
     
    19091909        Assert(pPciBusReg->pfnLoadExecR3);
    19101910        Assert(pPciBusReg->pfnFakePCIBIOSR3);
    1911         LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc (R3 callbacks)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     1911        LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc (R3 callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    19121912        return VERR_INVALID_PARAMETER;
    19131913    }
     
    19161916    {
    19171917        Assert(VALID_PTR(pPciBusReg->pszSetIrqRC));
    1918         LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc (GC callbacks)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     1918        LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc (GC callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    19191919        return VERR_INVALID_PARAMETER;
    19201920    }
     
    19231923    {
    19241924        Assert(VALID_PTR(pPciBusReg->pszSetIrqR0));
    1925         LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc (GC callbacks)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     1925        LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc (GC callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    19261926        return VERR_INVALID_PARAMETER;
    19271927    }
     
    19291929    {
    19301930        Assert(ppPciHlpR3);
    1931         LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc (ppPciHlpR3)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     1931        LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc (ppPciHlpR3)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    19321932        return VERR_INVALID_PARAMETER;
    19331933    }
     
    19431943    {
    19441944        AssertMsgFailed(("Too many PCI buses. Max=%u\n", RT_ELEMENTS(pVM->pdm.s.aPciBuses)));
    1945         LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc (pci bus)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     1945        LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc (pci bus)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    19461946        return VERR_INVALID_PARAMETER;
    19471947    }
     
    19571957        if (RT_FAILURE(rc))
    19581958        {
    1959             LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     1959            LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    19601960            return rc;
    19611961        }
     
    19771977        if (RT_FAILURE(rc))
    19781978        {
    1979             LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     1979            LogFlow(("pdmR3DevHlp_PCIRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    19801980            return rc;
    19811981        }
     
    20012001    pPciBus->pfnFakePCIBIOSR3        = pPciBusReg->pfnFakePCIBIOSR3;
    20022002
    2003     Log(("PDM: Registered PCI bus device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, pDevIns));
     2003    Log(("PDM: Registered PCI bus device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
    20042004
    20052005    /* set the helper pointer and return. */
    20062006    *ppPciHlpR3 = &g_pdmR3DevPciHlp;
    2007     LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VINF_SUCCESS));
     2007    LogFlow(("pdmR3DevHlp_PCIBusRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
    20082008    return VINF_SUCCESS;
    20092009}
     
    20162016    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    20172017    LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: pPicReg=%p:{.u32Version=%#x, .pfnSetIrqR3=%p, .pfnGetInterruptR3=%p, .pszGetIrqRC=%p:{%s}, .pszGetInterruptRC=%p:{%s}, .pszGetIrqR0=%p:{%s}, .pszGetInterruptR0=%p:{%s} } ppPicHlpR3=%p\n",
    2018              pDevIns->pReg->szDeviceName, pDevIns->iInstance, pPicReg, pPicReg->u32Version, pPicReg->pfnSetIrqR3, pPicReg->pfnGetInterruptR3,
     2018             pDevIns->pReg->szName, pDevIns->iInstance, pPicReg, pPicReg->u32Version, pPicReg->pfnSetIrqR3, pPicReg->pfnGetInterruptR3,
    20192019             pPicReg->pszSetIrqRC, pPicReg->pszSetIrqRC, pPicReg->pszGetInterruptRC, pPicReg->pszGetInterruptRC,
    20202020             pPicReg->pszSetIrqR0, pPicReg->pszSetIrqR0, pPicReg->pszGetInterruptR0, pPicReg->pszGetInterruptR0,
     
    20272027    {
    20282028        AssertMsgFailed(("u32Version=%#x expected %#x\n", pPicReg->u32Version, PDM_PICREG_VERSION));
    2029         LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2029        LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    20302030        return VERR_INVALID_PARAMETER;
    20312031    }
     
    20352035        Assert(pPicReg->pfnSetIrqR3);
    20362036        Assert(pPicReg->pfnGetInterruptR3);
    2037         LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (R3 callbacks)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2037        LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (R3 callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    20382038        return VERR_INVALID_PARAMETER;
    20392039    }
     
    20462046        Assert(VALID_PTR(pPicReg->pszSetIrqRC));
    20472047        Assert(VALID_PTR(pPicReg->pszGetInterruptRC));
    2048         LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (RC callbacks)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2048        LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (RC callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    20492049        return VERR_INVALID_PARAMETER;
    20502050    }
     
    20532053    {
    20542054        Assert(pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_RC);
    2055         LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (RC flag)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2055        LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (RC flag)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    20562056        return VERR_INVALID_PARAMETER;
    20572057    }
     
    20602060    {
    20612061        Assert(pDevIns->pReg->fFlags & PDM_DEVREG_FLAGS_R0);
    2062         LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (R0 flag)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2062        LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (R0 flag)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    20632063        return VERR_INVALID_PARAMETER;
    20642064    }
     
    20662066    {
    20672067        Assert(ppPicHlpR3);
    2068         LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (ppPicHlpR3)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2068        LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc (ppPicHlpR3)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    20692069        return VERR_INVALID_PARAMETER;
    20702070    }
     
    20772077    {
    20782078        AssertMsgFailed(("Only one pic device is supported!\n"));
    2079         LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2079        LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    20802080        return VERR_INVALID_PARAMETER;
    20812081    }
     
    20952095        if (RT_FAILURE(rc))
    20962096        {
    2097             LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     2097            LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    20982098            return rc;
    20992099        }
     
    21212121        if (RT_FAILURE(rc))
    21222122        {
    2123             LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     2123            LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    21242124            return rc;
    21252125        }
     
    21402140    pVM->pdm.s.Pic.pfnSetIrqR3 = pPicReg->pfnSetIrqR3;
    21412141    pVM->pdm.s.Pic.pfnGetInterruptR3 = pPicReg->pfnGetInterruptR3;
    2142     Log(("PDM: Registered PIC device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, pDevIns));
     2142    Log(("PDM: Registered PIC device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
    21432143
    21442144    /* set the helper pointer and return. */
    21452145    *ppPicHlpR3 = &g_pdmR3DevPicHlp;
    2146     LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VINF_SUCCESS));
     2146    LogFlow(("pdmR3DevHlp_PICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
    21472147    return VINF_SUCCESS;
    21482148}
     
    21572157             ".pfnSetTPRR3=%p, .pfnGetTPRR3=%p, .pfnWriteMSR3=%p, .pfnReadMSR3=%p, .pfnBusDeliverR3=%p, .pfnLocalInterruptR3=%p, pszGetInterruptRC=%p:{%s}, pszSetBaseRC=%p:{%s}, pszGetBaseRC=%p:{%s}, "
    21582158             ".pszSetTPRRC=%p:{%s}, .pszGetTPRRC=%p:{%s}, .pszWriteMSRRC=%p:{%s}, .pszReadMSRRC=%p:{%s}, .pszBusDeliverRC=%p:{%s}, .pszLocalInterruptRC=%p:{%s}} ppApicHlpR3=%p\n",
    2159              pDevIns->pReg->szDeviceName, pDevIns->iInstance, pApicReg, pApicReg->u32Version, pApicReg->pfnGetInterruptR3, pApicReg->pfnSetBaseR3,
     2159             pDevIns->pReg->szName, pDevIns->iInstance, pApicReg, pApicReg->u32Version, pApicReg->pfnGetInterruptR3, pApicReg->pfnSetBaseR3,
    21602160             pApicReg->pfnGetBaseR3, pApicReg->pfnSetTPRR3, pApicReg->pfnGetTPRR3, pApicReg->pfnWriteMSRR3, pApicReg->pfnReadMSRR3, pApicReg->pfnBusDeliverR3, pApicReg->pfnLocalInterruptR3, pApicReg->pszGetInterruptRC,
    21612161             pApicReg->pszGetInterruptRC, pApicReg->pszSetBaseRC, pApicReg->pszSetBaseRC, pApicReg->pszGetBaseRC, pApicReg->pszGetBaseRC,
     
    21692169    {
    21702170        AssertMsgFailed(("u32Version=%#x expected %#x\n", pApicReg->u32Version, PDM_APICREG_VERSION));
    2171         LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2171        LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    21722172        return VERR_INVALID_PARAMETER;
    21732173    }
     
    21932193        Assert(pApicReg->pfnBusDeliverR3);
    21942194        Assert(pApicReg->pfnLocalInterruptR3);
    2195         LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc (R3 callbacks)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2195        LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc (R3 callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    21962196        return VERR_INVALID_PARAMETER;
    21972197    }
     
    22282228        Assert(VALID_PTR(pApicReg->pszBusDeliverRC));
    22292229        Assert(VALID_PTR(pApicReg->pszLocalInterruptRC));
    2230         LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc (RC callbacks)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2230        LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc (RC callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    22312231        return VERR_INVALID_PARAMETER;
    22322232    }
     
    22632263        Assert(VALID_PTR(pApicReg->pszBusDeliverR0));
    22642264        Assert(VALID_PTR(pApicReg->pszLocalInterruptR0));
    2265         LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc (R0 callbacks)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2265        LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc (R0 callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    22662266        return VERR_INVALID_PARAMETER;
    22672267    }
     
    22692269    {
    22702270        Assert(ppApicHlpR3);
    2271         LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc (ppApicHlpR3)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2271        LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc (ppApicHlpR3)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    22722272        return VERR_INVALID_PARAMETER;
    22732273    }
     
    22812281    {
    22822282        AssertMsgFailed(("Only one apic device is supported!\n"));
    2283         LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2283        LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    22842284        return VERR_INVALID_PARAMETER;
    22852285    }
     
    23392339        if (RT_FAILURE(rc))
    23402340        {
    2341             LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     2341            LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    23422342            return rc;
    23432343        }
     
    24132413        if (RT_FAILURE(rc))
    24142414        {
    2415             LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     2415            LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    24162416            return rc;
    24172417        }
     
    24482448    pVM->pdm.s.Apic.pfnBusDeliverR3     = pApicReg->pfnBusDeliverR3;
    24492449    pVM->pdm.s.Apic.pfnLocalInterruptR3 = pApicReg->pfnLocalInterruptR3;
    2450     Log(("PDM: Registered APIC device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, pDevIns));
     2450    Log(("PDM: Registered APIC device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
    24512451
    24522452    /* set the helper pointer and return. */
    24532453    *ppApicHlpR3 = &g_pdmR3DevApicHlp;
    2454     LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VINF_SUCCESS));
     2454    LogFlow(("pdmR3DevHlp_APICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
    24552455    return VINF_SUCCESS;
    24562456}
     
    24632463    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    24642464    LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: pIoApicReg=%p:{.u32Version=%#x, .pfnSetIrqR3=%p, .pszSetIrqRC=%p:{%s}, .pszSetIrqR0=%p:{%s}} ppIoApicHlpR3=%p\n",
    2465              pDevIns->pReg->szDeviceName, pDevIns->iInstance, pIoApicReg, pIoApicReg->u32Version, pIoApicReg->pfnSetIrqR3,
     2465             pDevIns->pReg->szName, pDevIns->iInstance, pIoApicReg, pIoApicReg->u32Version, pIoApicReg->pfnSetIrqR3,
    24662466             pIoApicReg->pszSetIrqRC, pIoApicReg->pszSetIrqRC, pIoApicReg->pszSetIrqR0, pIoApicReg->pszSetIrqR0, ppIoApicHlpR3));
    24672467
     
    24722472    {
    24732473        AssertMsgFailed(("u32Version=%#x expected %#x\n", pIoApicReg->u32Version, PDM_IOAPICREG_VERSION));
    2474         LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2474        LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    24752475        return VERR_INVALID_PARAMETER;
    24762476    }
     
    24782478    {
    24792479        Assert(pIoApicReg->pfnSetIrqR3);
    2480         LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (R3 callbacks)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2480        LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (R3 callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    24812481        return VERR_INVALID_PARAMETER;
    24822482    }
     
    24852485    {
    24862486        Assert(VALID_PTR(pIoApicReg->pszSetIrqRC));
    2487         LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (GC callbacks)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2487        LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (GC callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    24882488        return VERR_INVALID_PARAMETER;
    24892489    }
     
    24922492    {
    24932493        Assert(VALID_PTR(pIoApicReg->pszSetIrqR0));
    2494         LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (GC callbacks)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2494        LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (GC callbacks)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    24952495        return VERR_INVALID_PARAMETER;
    24962496    }
     
    24982498    {
    24992499        Assert(ppIoApicHlpR3);
    2500         LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (ppApicHlp)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2500        LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (ppApicHlp)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    25012501        return VERR_INVALID_PARAMETER;
    25022502    }
     
    25102510    {
    25112511        AssertMsgFailed(("Configuration error / Init order error! No APIC!\n"));
    2512         LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (no APIC)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2512        LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (no APIC)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    25132513        return VERR_INVALID_PARAMETER;
    25142514    }
     
    25172517    {
    25182518        AssertMsgFailed(("Configuration error! APIC doesn't do GC, I/O APIC does!\n"));
    2519         LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (no GC APIC)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2519        LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (no GC APIC)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    25202520        return VERR_INVALID_PARAMETER;
    25212521    }
     
    25272527    {
    25282528        AssertMsgFailed(("Only one ioapic device is supported!\n"));
    2529         LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (only one)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2529        LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc (only one)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    25302530        return VERR_INVALID_PARAMETER;
    25312531    }
     
    25402540        if (RT_FAILURE(rc))
    25412541        {
    2542             LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     2542            LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    25432543            return rc;
    25442544        }
     
    25602560        if (RT_FAILURE(rc))
    25612561        {
    2562             LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     2562            LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    25632563            return rc;
    25642564        }
     
    25772577    pVM->pdm.s.IoApic.pDevInsR3   = pDevIns;
    25782578    pVM->pdm.s.IoApic.pfnSetIrqR3 = pIoApicReg->pfnSetIrqR3;
    2579     Log(("PDM: Registered I/O APIC device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, pDevIns));
     2579    Log(("PDM: Registered I/O APIC device '%s'/%d pDevIns=%p\n", pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
    25802580
    25812581    /* set the helper pointer and return. */
    25822582    *ppIoApicHlpR3 = &g_pdmR3DevIoApicHlp;
    2583     LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VINF_SUCCESS));
     2583    LogFlow(("pdmR3DevHlp_IOAPICRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
    25842584    return VINF_SUCCESS;
    25852585}
     
    25992599    {
    26002600        AssertMsgFailed(("u32Version=%#x expected %#x\n", pHpetReg->u32Version, PDM_HPETREG_VERSION));
    2601         LogFlow(("pdmR3DevHlp_HPETRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2601        LogFlow(("pdmR3DevHlp_HPETRegister: caller='%s'/%d: returns %Rrc (version)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    26022602        return VERR_INVALID_PARAMETER;
    26032603    }
     
    26062606    {
    26072607        Assert(ppHpetHlpR3);
    2608         LogFlow(("pdmR3DevHlp_HPETRegister: caller='%s'/%d: returns %Rrc (ppApicHlpR3)\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2608        LogFlow(("pdmR3DevHlp_HPETRegister: caller='%s'/%d: returns %Rrc (ppApicHlpR3)\n", pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    26092609        return VERR_INVALID_PARAMETER;
    26102610    }
     
    26122612    /* set the helper pointer and return. */
    26132613    *ppHpetHlpR3 = &g_pdmR3DevHpetHlp;
    2614     LogFlow(("pdmR3DevHlp_HPETRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, VINF_SUCCESS));
     2614    LogFlow(("pdmR3DevHlp_HPETRegister: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, VINF_SUCCESS));
    26152615    return VINF_SUCCESS;
    26162616}
     
    26232623    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    26242624    LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: pDmacReg=%p:{.u32Version=%#x, .pfnRun=%p, .pfnRegister=%p, .pfnReadMemory=%p, .pfnWriteMemory=%p, .pfnSetDREQ=%p, .pfnGetChannelMode=%p} ppDmacHlp=%p\n",
    2625              pDevIns->pReg->szDeviceName, pDevIns->iInstance, pDmacReg, pDmacReg->u32Version, pDmacReg->pfnRun, pDmacReg->pfnRegister,
     2625             pDevIns->pReg->szName, pDevIns->iInstance, pDmacReg, pDmacReg->u32Version, pDmacReg->pfnRun, pDmacReg->pfnRegister,
    26262626             pDmacReg->pfnReadMemory, pDmacReg->pfnWriteMemory, pDmacReg->pfnSetDREQ, pDmacReg->pfnGetChannelMode, ppDmacHlp));
    26272627
     
    26342634                         PDM_DMACREG_VERSION));
    26352635        LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc (version)\n",
    2636                  pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2636                 pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    26372637        return VERR_INVALID_PARAMETER;
    26382638    }
     
    26512651        Assert(pDmacReg->pfnGetChannelMode);
    26522652        LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc (callbacks)\n",
    2653                  pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2653                 pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    26542654        return VERR_INVALID_PARAMETER;
    26552655    }
     
    26592659        Assert(ppDmacHlp);
    26602660        LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc (ppDmacHlp)\n",
    2661                  pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2661                 pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    26622662        return VERR_INVALID_PARAMETER;
    26632663    }
     
    26712671        AssertMsgFailed(("Only one DMA device is supported!\n"));
    26722672        LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc\n",
    2673                  pDevIns->pReg->szDeviceName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
     2673                 pDevIns->pReg->szName, pDevIns->iInstance, VERR_INVALID_PARAMETER));
    26742674        return VERR_INVALID_PARAMETER;
    26752675    }
     
    26892689        *ppDmacHlp = &g_pdmR3DevDmacHlp;
    26902690        Log(("PDM: Registered DMAC device '%s'/%d pDevIns=%p\n",
    2691              pDevIns->pReg->szDeviceName, pDevIns->iInstance, pDevIns));
     2691             pDevIns->pReg->szName, pDevIns->iInstance, pDevIns));
    26922692    }
    26932693    else
     
    26952695
    26962696    LogFlow(("pdmR3DevHlp_DMACRegister: caller='%s'/%d: returns %Rrc\n",
    2697              pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     2697             pDevIns->pReg->szName, pDevIns->iInstance, rc));
    26982698    return rc;
    26992699}
     
    27332733    VM_ASSERT_EMT(pVM);
    27342734    LogFlow(("pdmR3DevHlp_VMReset: caller='%s'/%d: VM_FF_RESET %d -> 1\n",
    2735              pDevIns->pReg->szDeviceName, pDevIns->iInstance, VM_FF_ISSET(pVM, VM_FF_RESET)));
     2735             pDevIns->pReg->szName, pDevIns->iInstance, VM_FF_ISSET(pVM, VM_FF_RESET)));
    27362736
    27372737    /*
     
    27532753    }
    27542754
    2755     LogFlow(("pdmR3DevHlp_VMReset: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     2755    LogFlow(("pdmR3DevHlp_VMReset: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    27562756    return rc;
    27572757}
     
    27662766    VM_ASSERT_EMT(pVM);
    27672767    LogFlow(("pdmR3DevHlp_VMSuspend: caller='%s'/%d:\n",
    2768              pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     2768             pDevIns->pReg->szName, pDevIns->iInstance));
    27692769
    27702770    if (pVM->cCpus > 1)
     
    27782778        rc = VMR3Suspend(pVM);
    27792779
    2780     LogFlow(("pdmR3DevHlp_VMSuspend: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     2780    LogFlow(("pdmR3DevHlp_VMSuspend: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    27812781    return rc;
    27822782}
     
    27912791    VM_ASSERT_EMT(pVM);
    27922792    LogFlow(("pdmR3DevHlp_VMPowerOff: caller='%s'/%d:\n",
    2793              pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     2793             pDevIns->pReg->szName, pDevIns->iInstance));
    27942794
    27952795    if (pVM->cCpus > 1)
     
    28072807        rc = VMR3PowerOff(pVM);
    28082808
    2809     LogFlow(("pdmR3DevHlp_VMPowerOff: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     2809    LogFlow(("pdmR3DevHlp_VMPowerOff: caller='%s'/%d: returns %Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    28102810    return rc;
    28112811}
     
    28202820    bool fRc = PGMPhysIsA20Enabled(VMMGetCpu(pDevIns->Internal.s.pVMR3));
    28212821
    2822     LogFlow(("pdmR3DevHlp_A20IsEnabled: caller='%s'/%d: returns %d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, fRc));
     2822    LogFlow(("pdmR3DevHlp_A20IsEnabled: caller='%s'/%d: returns %d\n", pDevIns->pReg->szName, pDevIns->iInstance, fRc));
    28232823    return fRc;
    28242824}
     
    28302830    PDMDEV_ASSERT_DEVINS(pDevIns);
    28312831    VM_ASSERT_EMT(pDevIns->Internal.s.pVMR3);
    2832     LogFlow(("pdmR3DevHlp_A20Set: caller='%s'/%d: fEnable=%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, fEnable));
     2832    LogFlow(("pdmR3DevHlp_A20Set: caller='%s'/%d: fEnable=%d\n", pDevIns->pReg->szName, pDevIns->iInstance, fEnable));
    28332833    PGMR3PhysSetA20(VMMGetCpu(pDevIns->Internal.s.pVMR3), fEnable);
    28342834}
     
    28432843
    28442844    LogFlow(("pdmR3DevHlp_GetCpuId: caller='%s'/%d: iLeaf=%d pEax=%p pEbx=%p pEcx=%p pEdx=%p\n",
    2845              pDevIns->pReg->szDeviceName, pDevIns->iInstance, iLeaf, pEax, pEbx, pEcx, pEdx));
     2845             pDevIns->pReg->szName, pDevIns->iInstance, iLeaf, pEax, pEbx, pEcx, pEdx));
    28462846    AssertPtr(pEax); AssertPtr(pEbx); AssertPtr(pEcx); AssertPtr(pEdx);
    28472847
     
    28492849
    28502850    LogFlow(("pdmR3DevHlp_GetCpuId: caller='%s'/%d: returns void - *pEax=%#x *pEbx=%#x *pEcx=%#x *pEdx=%#x\n",
    2851              pDevIns->pReg->szDeviceName, pDevIns->iInstance, *pEax, *pEbx, *pEcx, *pEdx));
     2851             pDevIns->pReg->szName, pDevIns->iInstance, *pEax, *pEbx, *pEcx, *pEdx));
    28522852}
    28532853
     
    29622962{
    29632963    PDMDEV_ASSERT_DEVINS(pDevIns);
    2964     AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     2964    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
    29652965    return NULL;
    29662966}
     
    29712971{
    29722972    PDMDEV_ASSERT_DEVINS(pDevIns);
    2973     AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     2973    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
    29742974    return NULL;
    29752975}
     
    29802980{
    29812981    PDMDEV_ASSERT_DEVINS(pDevIns);
    2982     AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     2982    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
    29832983    return VERR_ACCESS_DENIED;
    29842984}
     
    29892989{
    29902990    PDMDEV_ASSERT_DEVINS(pDevIns);
    2991     AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     2991    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
    29922992    return VERR_ACCESS_DENIED;
    29932993}
     
    29982998{
    29992999    PDMDEV_ASSERT_DEVINS(pDevIns);
    3000     AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     3000    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
    30013001    return VERR_ACCESS_DENIED;
    30023002}
     
    30073007{
    30083008    PDMDEV_ASSERT_DEVINS(pDevIns);
    3009     AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     3009    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
    30103010    return VERR_ACCESS_DENIED;
    30113011}
     
    30163016{
    30173017    PDMDEV_ASSERT_DEVINS(pDevIns);
    3018     AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     3018    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
    30193019    return VERR_ACCESS_DENIED;
    30203020}
     
    30253025{
    30263026    PDMDEV_ASSERT_DEVINS(pDevIns);
    3027     AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     3027    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
    30283028    return false;
    30293029}
     
    30343034{
    30353035    PDMDEV_ASSERT_DEVINS(pDevIns);
    3036     AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     3036    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
    30373037    NOREF(fEnable);
    30383038}
     
    30443044{
    30453045    PDMDEV_ASSERT_DEVINS(pDevIns);
    3046     AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     3046    AssertReleaseMsgFailed(("Untrusted device called trusted helper! '%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
    30473047}
    30483048
  • trunk/src/VBox/VMM/PDMDevMiscHlp.cpp

    r26160 r26165  
    5252    {
    5353        LogFlow(("pdmR3PicHlp_SetInterruptFF: caller='%s'/%d: Setting local interrupt on LAPIC\n",
    54                  pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     54                 pDevIns->pReg->szName, pDevIns->iInstance));
    5555        /* Raise the LAPIC's LINT0 line instead of signaling the CPU directly. */
    5656        pVM->pdm.s.Apic.pfnLocalInterruptR3(pVM->pdm.s.Apic.pDevInsR3, 0, 1);
     
    6161
    6262    LogFlow(("pdmR3PicHlp_SetInterruptFF: caller='%s'/%d: VM_FF_INTERRUPT_PIC %d -> 1\n",
    63              pDevIns->pReg->szDeviceName, pDevIns->iInstance, VMCPU_FF_ISSET(pVCpu, VMCPU_FF_INTERRUPT_PIC)));
     63             pDevIns->pReg->szName, pDevIns->iInstance, VMCPU_FF_ISSET(pVCpu, VMCPU_FF_INTERRUPT_PIC)));
    6464
    6565    VMCPU_FF_SET(pVCpu, VMCPU_FF_INTERRUPT_PIC);
     
    8080        /* Raise the LAPIC's LINT0 line instead of signaling the CPU directly. */
    8181        LogFlow(("pdmR3PicHlp_ClearInterruptFF: caller='%s'/%d: Clearing local interrupt on LAPIC\n",
    82                  pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     82                 pDevIns->pReg->szName, pDevIns->iInstance));
    8383        /* Lower the LAPIC's LINT0 line instead of signaling the CPU directly. */
    8484        pVM->pdm.s.Apic.pfnLocalInterruptR3(pVM->pdm.s.Apic.pDevInsR3, 0, 0);
     
    8787
    8888    LogFlow(("pdmR3PicHlp_ClearInterruptFF: caller='%s'/%d: VM_FF_INTERRUPT_PIC %d -> 0\n",
    89              pDevIns->pReg->szDeviceName, pDevIns->iInstance, VMCPU_FF_ISSET(pVCpu, VMCPU_FF_INTERRUPT_PIC)));
     89             pDevIns->pReg->szName, pDevIns->iInstance, VMCPU_FF_ISSET(pVCpu, VMCPU_FF_INTERRUPT_PIC)));
    9090
    9191    VMCPU_FF_CLEAR(pVCpu, VMCPU_FF_INTERRUPT_PIC);
     
    120120    AssertRelease(pRCHelpers);
    121121    LogFlow(("pdmR3PicHlp_GetRCHelpers: caller='%s'/%d: returns %RRv\n",
    122              pDevIns->pReg->szDeviceName, pDevIns->iInstance, pRCHelpers));
     122             pDevIns->pReg->szName, pDevIns->iInstance, pRCHelpers));
    123123    return pRCHelpers;
    124124}
     
    135135    AssertRelease(pR0Helpers);
    136136    LogFlow(("pdmR3PicHlp_GetR0Helpers: caller='%s'/%d: returns %RHv\n",
    137              pDevIns->pReg->szDeviceName, pDevIns->iInstance, pR0Helpers));
     137             pDevIns->pReg->szName, pDevIns->iInstance, pR0Helpers));
    138138    return pR0Helpers;
    139139}
     
    174174
    175175    LogFlow(("pdmR3ApicHlp_SetInterruptFF: caller='%s'/%d: VM_FF_INTERRUPT(%d) %d -> 1\n",
    176              pDevIns->pReg->szDeviceName, pDevIns->iInstance, idCpu, VMCPU_FF_ISSET(pVCpu, VMCPU_FF_INTERRUPT_APIC)));
     176             pDevIns->pReg->szName, pDevIns->iInstance, idCpu, VMCPU_FF_ISSET(pVCpu, VMCPU_FF_INTERRUPT_APIC)));
    177177
    178178    switch (enmType)
     
    209209
    210210    LogFlow(("pdmR3ApicHlp_ClearInterruptFF: caller='%s'/%d: VM_FF_INTERRUPT(%d) %d -> 0\n",
    211              pDevIns->pReg->szDeviceName, pDevIns->iInstance, idCpu, VMCPU_FF_ISSET(pVCpu, VMCPU_FF_INTERRUPT_APIC)));
     211             pDevIns->pReg->szName, pDevIns->iInstance, idCpu, VMCPU_FF_ISSET(pVCpu, VMCPU_FF_INTERRUPT_APIC)));
    212212
    213213    /* Note: NMI/SMI can't be cleared. */
     
    233233    PDMDEV_ASSERT_DEVINS(pDevIns);
    234234    LogFlow(("pdmR3ApicHlp_ChangeFeature: caller='%s'/%d: version=%d\n",
    235              pDevIns->pReg->szDeviceName, pDevIns->iInstance, (int)enmVersion));
     235             pDevIns->pReg->szName, pDevIns->iInstance, (int)enmVersion));
    236236    switch (enmVersion)
    237237    {
     
    288288    AssertRelease(pRCHelpers);
    289289    LogFlow(("pdmR3ApicHlp_GetRCHelpers: caller='%s'/%d: returns %RRv\n",
    290              pDevIns->pReg->szDeviceName, pDevIns->iInstance, pRCHelpers));
     290             pDevIns->pReg->szName, pDevIns->iInstance, pRCHelpers));
    291291    return pRCHelpers;
    292292}
     
    303303    AssertRelease(pR0Helpers);
    304304    LogFlow(("pdmR3ApicHlp_GetR0Helpers: caller='%s'/%d: returns %RHv\n",
    305              pDevIns->pReg->szDeviceName, pDevIns->iInstance, pR0Helpers));
     305             pDevIns->pReg->szName, pDevIns->iInstance, pR0Helpers));
    306306    return pR0Helpers;
    307307}
     
    312312{
    313313    PDMDEV_ASSERT_DEVINS(pDevIns);
    314     LogFlow(("pdmR3ApicHlp_Lock: caller='%s'/%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     314    LogFlow(("pdmR3ApicHlp_Lock: caller='%s'/%d\n", pDevIns->pReg->szName, pDevIns->iInstance));
    315315    return &pDevIns->Internal.s.pVMR3->pdm.s.CritSect;
    316316}
     
    323323    PVM pVM = pDevIns->Internal.s.pVMR3;
    324324    RTRCPTR RCPtr = MMHyperCCToRC(pVM, &pVM->pdm.s.CritSect);
    325     LogFlow(("pdmR3ApicHlp_GetR0CritSect: caller='%s'/%d: return %RRv\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, RCPtr));
     325    LogFlow(("pdmR3ApicHlp_GetR0CritSect: caller='%s'/%d: return %RRv\n", pDevIns->pReg->szName, pDevIns->iInstance, RCPtr));
    326326    return RCPtr;
    327327}
     
    334334    PVM pVM = pDevIns->Internal.s.pVMR3;
    335335    RTR0PTR R0Ptr = MMHyperCCToR0(pVM, &pVM->pdm.s.CritSect);
    336     LogFlow(("pdmR3ApicHlp_GetR0CritSect: caller='%s'/%d: return %RHv\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, R0Ptr));
     336    LogFlow(("pdmR3ApicHlp_GetR0CritSect: caller='%s'/%d: return %RHv\n", pDevIns->pReg->szName, pDevIns->iInstance, R0Ptr));
    337337    return R0Ptr;
    338338}
     
    376376    PVM pVM = pDevIns->Internal.s.pVMR3;
    377377    LogFlow(("pdmR3IoApicHlp_ApicBusDeliver: caller='%s'/%d: u8Dest=%RX8 u8DestMode=%RX8 u8DeliveryMode=%RX8 iVector=%RX8 u8Polarity=%RX8 u8TriggerMode=%RX8\n",
    378              pDevIns->pReg->szDeviceName, pDevIns->iInstance, u8Dest, u8DestMode, u8DeliveryMode, iVector, u8Polarity, u8TriggerMode));
     378             pDevIns->pReg->szName, pDevIns->iInstance, u8Dest, u8DestMode, u8DeliveryMode, iVector, u8Polarity, u8TriggerMode));
    379379    if (pVM->pdm.s.Apic.pfnBusDeliverR3)
    380380        return pVM->pdm.s.Apic.pfnBusDeliverR3(pVM->pdm.s.Apic.pDevInsR3, u8Dest, u8DestMode, u8DeliveryMode, iVector, u8Polarity, u8TriggerMode);
     
    387387{
    388388    PDMDEV_ASSERT_DEVINS(pDevIns);
    389     LogFlow(("pdmR3IoApicHlp_Lock: caller='%s'/%d: rc=%Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     389    LogFlow(("pdmR3IoApicHlp_Lock: caller='%s'/%d: rc=%Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    390390    return pdmLockEx(pDevIns->Internal.s.pVMR3, rc);
    391391}
     
    396396{
    397397    PDMDEV_ASSERT_DEVINS(pDevIns);
    398     LogFlow(("pdmR3IoApicHlp_Unlock: caller='%s'/%d:\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     398    LogFlow(("pdmR3IoApicHlp_Unlock: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
    399399    pdmUnlock(pDevIns->Internal.s.pVMR3);
    400400}
     
    411411    AssertRelease(pRCHelpers);
    412412    LogFlow(("pdmR3IoApicHlp_GetRCHelpers: caller='%s'/%d: returns %RRv\n",
    413              pDevIns->pReg->szDeviceName, pDevIns->iInstance, pRCHelpers));
     413             pDevIns->pReg->szName, pDevIns->iInstance, pRCHelpers));
    414414    return pRCHelpers;
    415415}
     
    426426    AssertRelease(pR0Helpers);
    427427    LogFlow(("pdmR3IoApicHlp_GetR0Helpers: caller='%s'/%d: returns %RHv\n",
    428              pDevIns->pReg->szDeviceName, pDevIns->iInstance, pR0Helpers));
     428             pDevIns->pReg->szName, pDevIns->iInstance, pR0Helpers));
    429429    return pR0Helpers;
    430430}
     
    487487{
    488488    PDMDEV_ASSERT_DEVINS(pDevIns);
    489     LogFlow(("pdmR3PciHlp_Lock: caller='%s'/%d: rc=%Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     489    LogFlow(("pdmR3PciHlp_Lock: caller='%s'/%d: rc=%Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    490490    return pdmLockEx(pDevIns->Internal.s.pVMR3, rc);
    491491}
     
    496496{
    497497    PDMDEV_ASSERT_DEVINS(pDevIns);
    498     LogFlow(("pdmR3PciHlp_Unlock: caller='%s'/%d:\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     498    LogFlow(("pdmR3PciHlp_Unlock: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
    499499    pdmUnlock(pDevIns->Internal.s.pVMR3);
    500500}
     
    511511    AssertRelease(pRCHelpers);
    512512    LogFlow(("pdmR3IoApicHlp_GetGCHelpers: caller='%s'/%d: returns %RRv\n",
    513              pDevIns->pReg->szDeviceName, pDevIns->iInstance, pRCHelpers));
     513             pDevIns->pReg->szName, pDevIns->iInstance, pRCHelpers));
    514514    return pRCHelpers;
    515515}
     
    526526    AssertRelease(pR0Helpers);
    527527    LogFlow(("pdmR3IoApicHlp_GetR0Helpers: caller='%s'/%d: returns %RHv\n",
    528              pDevIns->pReg->szDeviceName, pDevIns->iInstance, pR0Helpers));
     528             pDevIns->pReg->szName, pDevIns->iInstance, pR0Helpers));
    529529    return pR0Helpers;
    530530}
     
    560560{
    561561    PDMDEV_ASSERT_DEVINS(pDevIns);
    562     LogFlow(("pdmR3HpetHlp_SetLegacyMode: caller='%s'/%d: fActivate=%d\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, fActivate));
     562    LogFlow(("pdmR3HpetHlp_SetLegacyMode: caller='%s'/%d: fActivate=%d\n", pDevIns->pReg->szName, pDevIns->iInstance, fActivate));
    563563    return 0;
    564564}
     
    569569{
    570570    PDMDEV_ASSERT_DEVINS(pDevIns);
    571     LogFlow(("pdmR3HpetHlp_Lock: caller='%s'/%d: rc=%Rrc\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     571    LogFlow(("pdmR3HpetHlp_Lock: caller='%s'/%d: rc=%Rrc\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    572572    return pdmLockEx(pDevIns->Internal.s.pVMR3, rc);
    573573}
     
    578578{
    579579    PDMDEV_ASSERT_DEVINS(pDevIns);
    580     LogFlow(("pdmR3HpetHlp_Unlock: caller='%s'/%d:\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     580    LogFlow(("pdmR3HpetHlp_Unlock: caller='%s'/%d:\n", pDevIns->pReg->szName, pDevIns->iInstance));
    581581    pdmUnlock(pDevIns->Internal.s.pVMR3);
    582582}
     
    593593    AssertRelease(pRCHelpers);
    594594    LogFlow(("pdmR3HpetHlp_GetGCHelpers: caller='%s'/%d: returns %RRv\n",
    595              pDevIns->pReg->szDeviceName, pDevIns->iInstance, pRCHelpers));
     595             pDevIns->pReg->szName, pDevIns->iInstance, pRCHelpers));
    596596    return pRCHelpers;
    597597}
     
    608608    AssertRelease(pR0Helpers);
    609609    LogFlow(("pdmR3HpetHlp_GetR0Helpers: caller='%s'/%d: returns %RHv\n",
    610              pDevIns->pReg->szDeviceName, pDevIns->iInstance, pR0Helpers));
     610             pDevIns->pReg->szName, pDevIns->iInstance, pR0Helpers));
    611611    return pR0Helpers;
    612612}
  • trunk/src/VBox/VMM/PDMDevice.cpp

    r26164 r26165  
    187187    {
    188188        /* Get the device name. */
    189         char szName[sizeof(paDevs[0].pDev->pReg->szDeviceName)];
     189        char szName[sizeof(paDevs[0].pDev->pReg->szName)];
    190190        rc = CFGMR3GetName(pCur, szName, sizeof(szName));
    191191        AssertMsgRCReturn(rc, ("Configuration error: device name is too long (or something)! rc=%Rrc\n", rc), rc);
     
    302302        {
    303303            AssertMsgFailed(("Failed to allocate %d bytes of instance data for device '%s'. rc=%Rrc\n",
    304                              cb, paDevs[i].pDev->pReg->szDeviceName, rc));
     304                             cb, paDevs[i].pDev->pReg->szName, rc));
    305305            return rc;
    306306        }
     
    366366         */
    367367        paDevs[i].pDev->cInstances++;
    368         Log(("PDM: Constructing device '%s' instance %d...\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance));
     368        Log(("PDM: Constructing device '%s' instance %d...\n", pDevIns->pReg->szName, pDevIns->iInstance));
    369369        rc = pDevIns->pReg->pfnConstruct(pDevIns, pDevIns->iInstance, pDevIns->pCfgHandle);
    370370        if (RT_FAILURE(rc))
    371371        {
    372             LogRel(("PDM: Failed to construct '%s'/%d! %Rra\n", pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     372            LogRel(("PDM: Failed to construct '%s'/%d! %Rra\n", pDevIns->pReg->szName, pDevIns->iInstance, rc));
    373373            paDevs[i].pDev->cInstances--;
    374374            /* because we're damn lazy right now, we'll say that the destructor will be called even if the constructor fails. */
     
    410410            {
    411411                AssertMsgFailed(("InitComplete on device '%s'/%d failed with rc=%Rrc\n",
    412                                  pDevIns->pReg->szDeviceName, pDevIns->iInstance, rc));
     412                                 pDevIns->pReg->szName, pDevIns->iInstance, rc));
    413413                return rc;
    414414            }
     
    437437    for (PPDMDEV pDev = pVM->pdm.s.pDevs; pDev; pDev = pDev->pNext)
    438438        if (    pDev->cchName == cchName
    439             &&  !strcmp(pDev->pReg->szDeviceName, pszName))
     439            &&  !strcmp(pDev->pReg->szName, pszName))
    440440            return pDev;
    441441    return NULL;
     
    612612                    VERR_PDM_UNKNOWN_DEVREG_VERSION);
    613613
    614     AssertMsgReturn(    pReg->szDeviceName[0]
    615                     &&  strlen(pReg->szDeviceName) < sizeof(pReg->szDeviceName),
    616                     ("Invalid name '%s'\n", pReg->szDeviceName),
     614    AssertMsgReturn(    pReg->szName[0]
     615                    &&  strlen(pReg->szName) < sizeof(pReg->szName),
     616                    ("Invalid name '%s'\n", pReg->szName),
    617617                    VERR_PDM_INVALID_DEVICE_REGISTRATION);
    618618    AssertMsgReturn(   !(pReg->fFlags & PDM_DEVREG_FLAGS_RC)
    619619                    || (   pReg->szRCMod[0]
    620620                        && strlen(pReg->szRCMod) < sizeof(pReg->szRCMod)),
    621                     ("Invalid GC module name '%s' - (Device %s)\n", pReg->szRCMod, pReg->szDeviceName),
     621                    ("Invalid GC module name '%s' - (Device %s)\n", pReg->szRCMod, pReg->szName),
    622622                    VERR_PDM_INVALID_DEVICE_REGISTRATION);
    623623    AssertMsgReturn(   !(pReg->fFlags & PDM_DEVREG_FLAGS_R0)
    624624                    || (   pReg->szR0Mod[0]
    625625                        && strlen(pReg->szR0Mod) < sizeof(pReg->szR0Mod)),
    626                     ("Invalid R0 module name '%s' - (Device %s)\n", pReg->szR0Mod, pReg->szDeviceName),
     626                    ("Invalid R0 module name '%s' - (Device %s)\n", pReg->szR0Mod, pReg->szName),
    627627                    VERR_PDM_INVALID_DEVICE_REGISTRATION);
    628628    AssertMsgReturn((pReg->fFlags & PDM_DEVREG_FLAGS_HOST_BITS_MASK) == PDM_DEVREG_FLAGS_HOST_BITS_DEFAULT,
    629                     ("Invalid host bits flags! fFlags=%#x (Device %s)\n", pReg->fFlags, pReg->szDeviceName),
     629                    ("Invalid host bits flags! fFlags=%#x (Device %s)\n", pReg->fFlags, pReg->szName),
    630630                    VERR_PDM_INVALID_DEVICE_HOST_BITS);
    631631    AssertMsgReturn((pReg->fFlags & PDM_DEVREG_FLAGS_GUEST_BITS_MASK),
    632                     ("Invalid guest bits flags! fFlags=%#x (Device %s)\n", pReg->fFlags, pReg->szDeviceName),
     632                    ("Invalid guest bits flags! fFlags=%#x (Device %s)\n", pReg->fFlags, pReg->szName),
    633633                    VERR_PDM_INVALID_DEVICE_REGISTRATION);
    634634    AssertMsgReturn(pReg->fClass,
    635                     ("No class! (Device %s)\n", pReg->szDeviceName),
     635                    ("No class! (Device %s)\n", pReg->szName),
    636636                    VERR_PDM_INVALID_DEVICE_REGISTRATION);
    637637    AssertMsgReturn(pReg->cMaxInstances > 0,
    638                     ("Max instances %u! (Device %s)\n", pReg->cMaxInstances, pReg->szDeviceName),
     638                    ("Max instances %u! (Device %s)\n", pReg->cMaxInstances, pReg->szName),
    639639                    VERR_PDM_INVALID_DEVICE_REGISTRATION);
    640640    AssertMsgReturn(pReg->cbInstance <= (uint32_t)(pReg->fFlags & (PDM_DEVREG_FLAGS_RC | PDM_DEVREG_FLAGS_R0)  ? 96 * _1K : _1M),
    641                     ("Instance size %d bytes! (Device %s)\n", pReg->cbInstance, pReg->szDeviceName),
     641                    ("Instance size %d bytes! (Device %s)\n", pReg->cbInstance, pReg->szName),
    642642                    VERR_PDM_INVALID_DEVICE_REGISTRATION);
    643643    AssertMsgReturn(pReg->pfnConstruct,
    644                     ("No constructore! (Device %s)\n", pReg->szDeviceName),
     644                    ("No constructore! (Device %s)\n", pReg->szName),
    645645                    VERR_PDM_INVALID_DEVICE_REGISTRATION);
    646646    AssertLogRelMsgReturn((pReg->fFlags & PDM_DEVREG_FLAGS_GUEST_BITS_MASK) == PDM_DEVREG_FLAGS_GUEST_BITS_DEFAULT,
    647                           ("PDM: Rejected device '%s' because it didn't match the guest bits.\n", pReg->szDeviceName),
     647                          ("PDM: Rejected device '%s' because it didn't match the guest bits.\n", pReg->szName),
    648648                          VERR_PDM_INVALID_DEVICE_GUEST_BITS);
    649649    AssertLogRelMsg(pReg->u32VersionEnd == PDM_DEVREG_VERSION,
    650                     ("u32VersionEnd=%#x, expected %#x. (szDeviceName=%s)\n",
    651                      pReg->u32VersionEnd, PDM_DEVREG_VERSION, pReg->szDeviceName));
     650                    ("u32VersionEnd=%#x, expected %#x. (szName=%s)\n",
     651                     pReg->u32VersionEnd, PDM_DEVREG_VERSION, pReg->szName));
    652652
    653653    /*
     
    658658    PPDMDEV pDev = pRegCB->pVM->pdm.s.pDevs;
    659659    for (; pDev; pDevPrev = pDev, pDev = pDev->pNext)
    660         AssertMsgReturn(strcmp(pDev->pReg->szDeviceName, pReg->szDeviceName),
    661                         ("Device '%s' already exists\n", pReg->szDeviceName),
     660        AssertMsgReturn(strcmp(pDev->pReg->szName, pReg->szName),
     661                        ("Device '%s' already exists\n", pReg->szName),
    662662                        VERR_PDM_DEVICE_NAME_CLASH);
    663663
     
    672672        pDev->pInstances = NULL;
    673673        pDev->pReg = pReg;
    674         pDev->cchName = (uint32_t)strlen(pReg->szDeviceName);
     674        pDev->cchName = (uint32_t)strlen(pReg->szName);
    675675
    676676        if (pDevPrev)
     
    678678        else
    679679            pRegCB->pVM->pdm.s.pDevs = pDev;
    680         Log(("PDM: Registered device '%s'\n", pReg->szDeviceName));
     680        Log(("PDM: Registered device '%s'\n", pReg->szName));
    681681        return VINF_SUCCESS;
    682682    }
     
    705705    {
    706706        if (    pDev->cchName == cchDevice
    707             &&  !memcmp(pDev->pReg->szDeviceName, pszDevice, cchDevice))
     707            &&  !memcmp(pDev->pReg->szName, pszDevice, cchDevice))
    708708        {
    709709            /*
  • trunk/src/VBox/VMM/PDMDriver.cpp

    r26163 r26165  
    502502                                 pNew, pDrv->pReg->szDriverName, pNew->iInstance,
    503503                                 pLun->iLun,
    504                                  pLun->pDevIns ? pLun->pDevIns->pReg->szDeviceName : pLun->pUsbIns->pReg->szDeviceName,
     504                                 pLun->pDevIns ? pLun->pDevIns->pReg->szName : pLun->pUsbIns->pReg->szName,
    505505                                 pLun->pDevIns ? pLun->pDevIns->iInstance             : pLun->pUsbIns->iInstance,
    506506                                 pDrvAbove, pDrvAbove ? pDrvAbove->pReg->szDriverName : "", pDrvAbove ? pDrvAbove->iInstance : -1));
  • trunk/src/VBox/VMM/PGMSavedState.cpp

    r26160 r26165  
    290290        AssertLogRelReturn(id != 0, VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
    291291
    292         char szDevName[RT_SIZEOFMEMB(PDMDEVREG, szDeviceName)];
     292        char szDevName[RT_SIZEOFMEMB(PDMDEVREG, szName)];
    293293        rc = SSMR3GetStrZ(pSSM, szDevName, sizeof(szDevName));
    294294        AssertLogRelRCReturn(rc, rc);
     
    627627        pMmio2->idSavedState = id;
    628628        SSMR3PutU8(pSSM, id);
    629         SSMR3PutStrZ(pSSM, pMmio2->pDevInsR3->pReg->szDeviceName);
     629        SSMR3PutStrZ(pSSM, pMmio2->pDevInsR3->pReg->szName);
    630630        SSMR3PutU32(pSSM, pMmio2->pDevInsR3->iInstance);
    631631        SSMR3PutU8(pSSM, pMmio2->iRegion);
     
    672672        AssertLogRelReturn(id != 0, VERR_SSM_DATA_UNIT_FORMAT_CHANGED);
    673673
    674         char szDevName[RT_SIZEOFMEMB(PDMDEVREG, szDeviceName)];
     674        char szDevName[RT_SIZEOFMEMB(PDMDEVREG, szName)];
    675675        rc = SSMR3GetStrZ(pSSM, szDevName, sizeof(szDevName));
    676676        AssertLogRelRCReturn(rc, rc);
     
    698698                &&  pMmio2->iRegion == iRegion
    699699                &&  pMmio2->pDevInsR3->iInstance == uInstance
    700                 &&  !strcmp(pMmio2->pDevInsR3->pReg->szDeviceName, szDevName))
     700                &&  !strcmp(pMmio2->pDevInsR3->pReg->szName, szDevName))
    701701            {
    702702                pMmio2->idSavedState = id;
Note: See TracChangeset for help on using the changeset viewer.

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