VirtualBox

Changeset 90802 in vbox for trunk/src/VBox/Storage


Ignore:
Timestamp:
Aug 23, 2021 7:08:27 PM (3 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
146437
Message:

Storage: More VALID_PTR -> RT_VALID_PTR/AssertPtr.

Location:
trunk/src/VBox/Storage
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Storage/CUE.cpp

    r90296 r90802  
    14511451    int rc = VINF_SUCCESS;
    14521452
    1453     AssertReturn((VALID_PTR(pszFilename) && *pszFilename), VERR_INVALID_PARAMETER);
     1453    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
     1454    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
     1455
    14541456
    14551457    PCUEIMAGE pThis = (PCUEIMAGE)RTMemAllocZ(sizeof(CUEIMAGE));
    … …  
    14891491    /* Check open flags. All valid flags are supported. */
    14901492    AssertReturn(!(uOpenFlags & ~VD_OPEN_FLAGS_MASK), VERR_INVALID_PARAMETER);
    1491     AssertReturn((VALID_PTR(pszFilename) && *pszFilename), VERR_INVALID_PARAMETER);
     1493    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
     1494    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
     1495
    14921496    AssertReturn(enmType == VDTYPE_OPTICAL_DISC, VERR_NOT_SUPPORTED);
    14931497

  • trunk/src/VBox/Storage/ISCSI.cpp

    r85121 r90802  
    776776        if (pIScsiCmdPrev)
    777777        {
    778             Assert(!pIScsiCmd->pNext || VALID_PTR(pIScsiCmd->pNext));
     778            AssertPtrNull(pIScsiCmd->pNext);
    779779            pIScsiCmdPrev->pNext = pIScsiCmd->pNext;
    780780        }
    … …  
    782782        {
    783783            pImage->aCmdsWaiting[idx] = pIScsiCmd->pNext;
    784             Assert(!pImage->aCmdsWaiting[idx] || VALID_PTR(pImage->aCmdsWaiting[idx]));
     784            AssertPtrNull(pImage->aCmdsWaiting[idx]);
    785785        }
    786786        pImage->cCmdsWaiting--;
    … …  
    47934793    /* Check open flags. All valid flags are supported. */
    47944794    AssertReturn(!(uOpenFlags & ~VD_OPEN_FLAGS_MASK), VERR_INVALID_PARAMETER);
    4795     AssertReturn((VALID_PTR(pszFilename) && *pszFilename), VERR_INVALID_PARAMETER);
     4795    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
     4796    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
    47964797
    47974798    PISCSIIMAGE pImage = (PISCSIIMAGE)RTMemAllocZ(RT_UOFFSETOF(ISCSIIMAGE, RegionList.aRegions[1]));

  • trunk/src/VBox/Storage/Parallels.cpp

    r82968 r90802  
    448448    /* Check parameters. */
    449449    AssertReturn(!(uOpenFlags & ~VD_OPEN_FLAGS_MASK), VERR_INVALID_PARAMETER);
    450     AssertReturn(VALID_PTR(pszFilename) && *pszFilename, VERR_INVALID_PARAMETER);
     450    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
     451    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
     452
    451453
    452454    pImage = (PPARALLELSIMAGE)RTMemAllocZ(RT_UOFFSETOF(PARALLELSIMAGE, RegionList.aRegions[1]));
    … …  
    493495    /* Check arguments. */
    494496    AssertReturn(!(uOpenFlags & ~VD_OPEN_FLAGS_MASK), VERR_INVALID_PARAMETER);
    495     AssertReturn(   VALID_PTR(pszFilename)
    496                  && *pszFilename
    497                  && VALID_PTR(pPCHSGeometry)
    498                  && VALID_PTR(pLCHSGeometry), VERR_INVALID_PARAMETER);
     497    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
     498    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
     499    AssertPtrReturn(pPCHSGeometry, VERR_INVALID_POINTER);
     500    AssertPtrReturn(pLCHSGeometry, VERR_INVALID_POINTER);
    499501
    500502    int rc = VINF_SUCCESS;

  • trunk/src/VBox/Storage/QCOW.cpp

    r82968 r90802  
    17201720    PVDINTERFACEIOINT pIfIo = VDIfIoIntGet(pVDIfsImage);
    17211721    AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
    1722     AssertReturn((VALID_PTR(pszFilename) && *pszFilename), VERR_INVALID_PARAMETER);
     1722    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
     1723    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
    17231724
    17241725    /*
    … …  
    17681769    /* Check open flags. All valid flags are supported. */
    17691770    AssertReturn(!(uOpenFlags & ~VD_OPEN_FLAGS_MASK), VERR_INVALID_PARAMETER);
    1770     AssertReturn((VALID_PTR(pszFilename) && *pszFilename), VERR_INVALID_PARAMETER);
     1771    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
     1772    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
     1773
    17711774
    17721775    PQCOWIMAGE pImage = (PQCOWIMAGE)RTMemAllocZ(RT_UOFFSETOF(QCOWIMAGE, RegionList.aRegions[1]));
    … …  
    18121815    /* Check open flags. All valid flags are supported. */
    18131816    AssertReturn(!(uOpenFlags & ~VD_OPEN_FLAGS_MASK), VERR_INVALID_PARAMETER);
    1814     AssertReturn(   VALID_PTR(pszFilename)
    1815                  && *pszFilename
    1816                  && VALID_PTR(pPCHSGeometry)
    1817                  && VALID_PTR(pLCHSGeometry), VERR_INVALID_PARAMETER);
     1817    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
     1818    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
     1819    AssertPtrReturn(pPCHSGeometry, VERR_INVALID_POINTER);
     1820    AssertPtrReturn(pLCHSGeometry, VERR_INVALID_POINTER);
    18181821
    18191822    PQCOWIMAGE pImage = (PQCOWIMAGE)RTMemAllocZ(RT_UOFFSETOF(QCOWIMAGE, RegionList.aRegions[1]));
    … …  
    19191922    Assert(uOffset % 512 == 0);
    19201923    Assert(cbToRead % 512 == 0);
    1921     AssertReturn((VALID_PTR(pIoCtx) && cbToRead), VERR_INVALID_PARAMETER);
     1924    AssertPtrReturn(pIoCtx, VERR_INVALID_POINTER);
     1925    AssertReturn(cbToRead, VERR_INVALID_PARAMETER);
    19221926    AssertReturn(uOffset + cbToRead <= pImage->cbSize, VERR_INVALID_PARAMETER);
    19231927
    … …  
    19671971    Assert(!(uOffset % 512));
    19681972    Assert(!(cbToWrite % 512));
    1969     AssertReturn((VALID_PTR(pIoCtx) && cbToWrite), VERR_INVALID_PARAMETER);
     1973    AssertPtrReturn(pIoCtx, VERR_INVALID_POINTER);
     1974    AssertReturn(cbToWrite, VERR_INVALID_PARAMETER);
    19701975    AssertReturn(uOffset + cbToWrite <= pImage->cbSize, VERR_INVALID_PARAMETER);
    19711976

  • trunk/src/VBox/Storage/QED.cpp

    r82968 r90802  
    15131513    PVDINTERFACEIOINT pIfIo = VDIfIoIntGet(pVDIfsImage);
    15141514    AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
    1515     AssertReturn((VALID_PTR(pszFilename) && *pszFilename), VERR_INVALID_PARAMETER);
     1515    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
     1516    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
     1517
    15161518
    15171519    /*
    … …  
    15631565    /* Check open flags. All valid flags are supported. */
    15641566    AssertReturn(!(uOpenFlags & ~VD_OPEN_FLAGS_MASK), VERR_INVALID_PARAMETER);
    1565     AssertReturn((VALID_PTR(pszFilename) && *pszFilename), VERR_INVALID_PARAMETER);
     1567    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
     1568    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
     1569
    15661570
    15671571    PQEDIMAGE pImage = (PQEDIMAGE)RTMemAllocZ(RT_UOFFSETOF(QEDIMAGE, RegionList.aRegions[1]));
    … …  
    16071611    /* Check open flags. All valid flags are supported. */
    16081612    AssertReturn(!(uOpenFlags & ~VD_OPEN_FLAGS_MASK), VERR_INVALID_PARAMETER);
    1609     AssertReturn(   VALID_PTR(pszFilename)
    1610                  && *pszFilename
    1611                  && VALID_PTR(pPCHSGeometry)
    1612                  && VALID_PTR(pLCHSGeometry), VERR_INVALID_PARAMETER);
     1613    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
     1614    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
     1615    AssertPtrReturn(pPCHSGeometry, VERR_INVALID_POINTER);
     1616    AssertPtrReturn(pLCHSGeometry, VERR_INVALID_POINTER);
    16131617
    16141618    PQEDIMAGE pImage = (PQEDIMAGE)RTMemAllocZ(RT_UOFFSETOF(QEDIMAGE, RegionList.aRegions[1]));
    … …  
    17141718    Assert(uOffset % 512 == 0);
    17151719    Assert(cbToRead % 512 == 0);
    1716     AssertReturn((VALID_PTR(pIoCtx) && cbToRead), VERR_INVALID_PARAMETER);
     1720    AssertPtrReturn(pIoCtx, VERR_INVALID_POINTER);
     1721    AssertReturn(cbToRead, VERR_INVALID_PARAMETER);
    17171722    AssertReturn(uOffset + cbToRead <= pImage->cbSize, VERR_INVALID_PARAMETER);
    17181723
    … …  
    17551760    Assert(!(uOffset % 512));
    17561761    Assert(!(cbToWrite % 512));
    1757     AssertReturn((VALID_PTR(pIoCtx) && cbToWrite), VERR_INVALID_PARAMETER);
     1762    AssertPtrReturn(pIoCtx, VERR_INVALID_POINTER);
     1763    AssertReturn(cbToWrite, VERR_INVALID_PARAMETER);
    17581764    AssertReturn(uOffset + cbToWrite <= pImage->cbSize, VERR_INVALID_PARAMETER);
    17591765

  • trunk/src/VBox/Storage/RAW.cpp

    r86500 r90802  
    526526
    527527    AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
    528     AssertReturn((VALID_PTR(pszFilename) && *pszFilename), VERR_INVALID_PARAMETER);
     528    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
     529    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
    529530
    530531    /*
    … …  
    676677    /* Check open flags. All valid flags are supported. */
    677678    AssertReturn(!(uOpenFlags & ~VD_OPEN_FLAGS_MASK), VERR_INVALID_PARAMETER);
    678     AssertReturn((VALID_PTR(pszFilename) && *pszFilename), VERR_INVALID_PARAMETER);
     679    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
     680    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
    679681
    680682    pImage = (PRAWIMAGE)RTMemAllocZ(RT_UOFFSETOF(RAWIMAGE, RegionList.aRegions[1]));
    … …  
    728730    /* Check arguments. */
    729731    AssertReturn(!(uOpenFlags & ~VD_OPEN_FLAGS_MASK), VERR_INVALID_PARAMETER);
    730     AssertReturn(   VALID_PTR(pszFilename)
    731                  && *pszFilename
    732                  && VALID_PTR(pPCHSGeometry)
    733                  && VALID_PTR(pLCHSGeometry), VERR_INVALID_PARAMETER);
     732    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
     733    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
     734    AssertPtrReturn(pPCHSGeometry, VERR_INVALID_POINTER);
     735    AssertPtrReturn(pLCHSGeometry, VERR_INVALID_POINTER);
    734736
    735737    PRAWIMAGE pImage = (PRAWIMAGE)RTMemAllocZ(RT_UOFFSETOF(RAWIMAGE, RegionList.aRegions[1]));

  • trunk/src/VBox/Storage/VCICache.cpp

    r82968 r90802  
    15301530
    15311531    /* Check remaining arguments. */
    1532     if (   !VALID_PTR(pszFilename)
     1532    if (   !RT_VALID_PTR(pszFilename)
    15331533        || !*pszFilename)
    15341534    {
    … …  
    15911591
    15921592    /* Check remaining arguments. */
    1593     if (   !VALID_PTR(pszFilename)
     1593    if (   !RT_VALID_PTR(pszFilename)
    15941594        || !*pszFilename)
    15951595    {

  • trunk/src/VBox/Storage/VD.cpp

    r88528 r90802  
    27142714                                                         ? vdWriteHelperStandardAsync
    27152715                                                         : vdWriteHelperOptimizedAsync);
    2716                 if (!VALID_PTR(pIoCtxWrite))
     2716                if (!pIoCtxWrite)
    27172717                {
    27182718                    RTMemTmpFree(pTmp);
    … …  
    42534253        }
    42544254
    4255         Assert(VALID_PTR(pMetaXfer) || RT_FAILURE(rc));
     4255        Assert(RT_VALID_PTR(pMetaXfer) || RT_FAILURE(rc));
    42564256
    42574257        if (RT_SUCCESS(rc) || rc == VERR_VD_NOT_ENOUGH_METADATA || rc == VERR_VD_ASYNC_IO_IN_PROGRESS)
    … …  
    51015101    LogFlowFunc(("cEntriesAlloc=%u pEntries=%#p pcEntriesUsed=%#p\n", cEntriesAlloc, pEntries, pcEntriesUsed));
    51025102    /* Check arguments. */
    5103     AssertMsgReturn(cEntriesAlloc,
    5104                     ("cEntriesAlloc=%u\n", cEntriesAlloc),
    5105                     VERR_INVALID_PARAMETER);
    5106     AssertMsgReturn(VALID_PTR(pEntries),
    5107                     ("pEntries=%#p\n", pEntries),
    5108                     VERR_INVALID_PARAMETER);
    5109     AssertMsgReturn(VALID_PTR(pcEntriesUsed),
    5110                     ("pcEntriesUsed=%#p\n", pcEntriesUsed),
    5111                     VERR_INVALID_PARAMETER);
     5103    AssertMsgReturn(cEntriesAlloc, ("cEntriesAlloc=%u\n", cEntriesAlloc), VERR_INVALID_PARAMETER);
     5104    AssertPtrReturn(pEntries, VERR_INVALID_POINTER);
     5105    AssertPtrReturn(pcEntriesUsed, VERR_INVALID_POINTER);
    51125106    if (!vdPluginIsInitialized())
    51135107        VDInit();
    … …  
    51445138    LogFlowFunc(("pszBackend=%#p pEntry=%#p\n", pszBackend, pEntry));
    51455139    /* Check arguments. */
    5146     AssertMsgReturn(VALID_PTR(pszBackend),
    5147                     ("pszBackend=%#p\n", pszBackend),
    5148                     VERR_INVALID_PARAMETER);
    5149     AssertMsgReturn(VALID_PTR(pEntry),
    5150                     ("pEntry=%#p\n", pEntry),
    5151                     VERR_INVALID_PARAMETER);
     5140    AssertPtrReturn(pszBackend, VERR_INVALID_POINTER);
     5141    AssertPtrReturn(pEntry, VERR_INVALID_POINTER);
    51525142    if (!vdPluginIsInitialized())
    51535143        VDInit();
    … …  
    51775167                    ("cEntriesAlloc=%u\n", cEntriesAlloc),
    51785168                    VERR_INVALID_PARAMETER);
    5179     AssertMsgReturn(VALID_PTR(pEntries),
    5180                     ("pEntries=%#p\n", pEntries),
    5181                     VERR_INVALID_PARAMETER);
    5182     AssertMsgReturn(VALID_PTR(pcEntriesUsed),
    5183                     ("pcEntriesUsed=%#p\n", pcEntriesUsed),
    5184                     VERR_INVALID_PARAMETER);
     5169    AssertPtrReturn(pEntries, VERR_INVALID_POINTER);
     5170    AssertPtrReturn(pcEntriesUsed, VERR_INVALID_POINTER);
    51855171    if (!vdPluginIsInitialized())
    51865172        VDInit();
    … …  
    52115197    LogFlowFunc(("pszFilter=%#p pEntry=%#p\n", pszFilter, pEntry));
    52125198    /* Check arguments. */
    5213     AssertMsgReturn(VALID_PTR(pszFilter),
    5214                     ("pszFilter=%#p\n", pszFilter),
    5215                     VERR_INVALID_PARAMETER);
    5216     AssertMsgReturn(VALID_PTR(pEntry),
    5217                     ("pEntry=%#p\n", pEntry),
    5218                     VERR_INVALID_PARAMETER);
     5199    AssertPtrReturn(pszFilter, VERR_INVALID_POINTER);
     5200    AssertPtrReturn(pEntry, VERR_INVALID_POINTER);
    52195201    if (!vdPluginIsInitialized())
    52205202        VDInit();
    … …  
    52385220
    52395221    LogFlowFunc(("pVDIfsDisk=%#p\n", pVDIfsDisk));
     5222    /* Check arguments. */
     5223    AssertPtrReturn(ppDisk, VERR_INVALID_POINTER);
     5224
    52405225    do
    52415226    {
    5242         /* Check arguments. */
    5243         AssertMsgBreakStmt(VALID_PTR(ppDisk),
    5244                            ("ppDisk=%#p\n", ppDisk),
    5245                            rc = VERR_INVALID_PARAMETER);
    5246 
    52475227        pDisk = (PVDISK)RTMemAllocZ(sizeof(VDISK));
    52485228        if (pDisk)
    … …  
    53455325    LogFlowFunc(("pszFilename=\"%s\"\n", pszFilename));
    53465326    /* Check arguments. */
    5347     AssertMsgReturn(VALID_PTR(pszFilename) && *pszFilename,
    5348                     ("pszFilename=%#p \"%s\"\n", pszFilename, pszFilename),
    5349                     VERR_INVALID_PARAMETER);
    5350     AssertMsgReturn(VALID_PTR(ppszFormat),
    5351                     ("ppszFormat=%#p\n", ppszFormat),
    5352                     VERR_INVALID_PARAMETER);
    5353     AssertMsgReturn(VALID_PTR(penmType),
    5354                     ("penmType=%#p\n", penmType),
    5355                     VERR_INVALID_PARAMETER);
     5327    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
     5328    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
     5329    AssertPtrReturn(ppszFormat, VERR_INVALID_POINTER);
     5330    AssertPtrReturn(penmType, VERR_INVALID_POINTER);
    53565331    AssertReturn(enmDesiredType >= VDTYPE_INVALID && enmDesiredType <= VDTYPE_FLOPPY, VERR_INVALID_PARAMETER);
    53575332
    … …  
    55005475    LogFlowFunc(("pDisk=%#p pszBackend=\"%s\" pszFilename=\"%s\" uOpenFlags=%#x, pVDIfsImage=%#p\n",
    55015476                 pDisk, pszBackend, pszFilename, uOpenFlags, pVDIfsImage));
     5477    /* sanity check */
     5478    AssertPtrReturn(pDisk, VERR_INVALID_PARAMETER);
     5479    AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
     5480
     5481    /* Check arguments. */
     5482    AssertPtrReturn(pszBackend, VERR_INVALID_POINTER);
     5483    AssertReturn(*pszBackend != '\0', VERR_INVALID_PARAMETER);
     5484    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
     5485    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
     5486    AssertMsgReturn((uOpenFlags & ~VD_OPEN_FLAGS_MASK) == 0,
     5487                    ("uOpenFlags=%#x\n", uOpenFlags),
     5488                    VERR_INVALID_PARAMETER);
     5489    AssertMsgReturn(   !(uOpenFlags & VD_OPEN_FLAGS_SKIP_CONSISTENCY_CHECKS)
     5490                    ||  (uOpenFlags & VD_OPEN_FLAGS_READONLY),
     5491                    ("uOpenFlags=%#x\n", uOpenFlags),
     5492                    VERR_INVALID_PARAMETER);
    55025493
    55035494    do
    55045495    {
    5505         /* sanity check */
    5506         AssertPtrBreakStmt(pDisk, rc = VERR_INVALID_PARAMETER);
    5507         AssertMsg(pDisk->u32Signature == VDISK_SIGNATURE, ("u32Signature=%08x\n", pDisk->u32Signature));
    5508 
    5509         /* Check arguments. */
    5510         AssertMsgBreakStmt(VALID_PTR(pszBackend) && *pszBackend,
    5511                            ("pszBackend=%#p \"%s\"\n", pszBackend, pszBackend),
    5512                            rc = VERR_INVALID_PARAMETER);
    5513         AssertMsgBreakStmt(VALID_PTR(pszFilename) && *pszFilename,
    5514                            ("pszFilename=%#p \"%s\"\n", pszFilename, pszFilename),
    5515                            rc = VERR_INVALID_PARAMETER);
    5516         AssertMsgBreakStmt((uOpenFlags & ~VD_OPEN_FLAGS_MASK) == 0,
    5517                            ("uOpenFlags=%#x\n", uOpenFlags),
    5518                            rc = VERR_INVALID_PARAMETER);
    5519         AssertMsgBreakStmt(   !(uOpenFlags & VD_OPEN_FLAGS_SKIP_CONSISTENCY_CHECKS)
    5520                            ||  (uOpenFlags & VD_OPEN_FLAGS_READONLY),
    5521                            ("uOpenFlags=%#x\n", uOpenFlags),
    5522                            rc = VERR_INVALID_PARAMETER);
    5523 
    55245496        /*
    55255497         * Destroy the current discard state first which might still have pending blocks
    … …  
    99839955                    ("pszFilename=%#p \"%s\"\n", pszFilename, pszFilename),
    99849956                    VERR_INVALID_PARAMETER);
    9985     AssertMsgReturn(VALID_PTR(pszBackend),
    9986                     ("pszBackend=%#p\n", pszBackend),
    9987                     VERR_INVALID_PARAMETER);
     9957    AssertPtrReturn(pszBackend, VERR_INVALID_POINTER);
    99889958    AssertMsgReturn((fFlags & ~VD_REPAIR_FLAGS_MASK) == 0,
    99899959                    ("fFlags=%#x\n", fFlags),

  • trunk/src/VBox/Storage/VDI.cpp

    r85121 r90802  
    715715
    716716    /* Special check for comment length. */
    717     if (   VALID_PTR(pszComment)
     717    if (   RT_VALID_PTR(pszComment)
    718718        && strlen(pszComment) >= VDI_IMAGE_COMMENT_SIZE)
    719719        rc = vdIfError(pImage->pIfError, VERR_VD_VDI_COMMENT_TOO_LONG, RT_SRC_POS,
    … …  
    14171417    int rc = VINF_SUCCESS;
    14181418
    1419     AssertReturn((VALID_PTR(pszFilename) && *pszFilename), VERR_INVALID_PARAMETER);
     1419    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
     1420    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
     1421
    14201422
    14211423    PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)RTMemAllocZ(RT_UOFFSETOF(VDIIMAGEDESC, RegionList.aRegions[1]));
    … …  
    14551457    /* Check open flags. All valid flags are supported. */
    14561458    AssertReturn(!(uOpenFlags & ~VD_OPEN_FLAGS_MASK), VERR_INVALID_PARAMETER);
    1457     AssertReturn((VALID_PTR(pszFilename) && *pszFilename), VERR_INVALID_PARAMETER);
     1459    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
     1460    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
     1461
    14581462
    14591463    PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)RTMemAllocZ(RT_UOFFSETOF(VDIIMAGEDESC, RegionList.aRegions[1]));
    … …  
    15081512    /* Check open flags. All valid flags are supported. */
    15091513    AssertReturn(!(uOpenFlags & ~VD_OPEN_FLAGS_MASK), VERR_INVALID_PARAMETER);
    1510     AssertReturn(   VALID_PTR(pszFilename)
    1511                  && *pszFilename
    1512                  && VALID_PTR(pPCHSGeometry)
    1513                  && VALID_PTR(pLCHSGeometry), VERR_INVALID_PARAMETER);
     1514    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
     1515    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
     1516    AssertPtrReturn(pPCHSGeometry, VERR_INVALID_POINTER);
     1517    AssertPtrReturn(pLCHSGeometry, VERR_INVALID_POINTER);
    15141518
    15151519    PVDIIMAGEDESC pImage = (PVDIIMAGEDESC)RTMemAllocZ(RT_UOFFSETOF(VDIIMAGEDESC, RegionList.aRegions[1]));
    … …  
    16141618    Assert(!(uOffset % 512));
    16151619    Assert(!(cbToRead % 512));
    1616     AssertReturn((VALID_PTR(pIoCtx) && cbToRead), VERR_INVALID_PARAMETER);
     1620    AssertPtrReturn(pIoCtx, VERR_INVALID_POINTER);
     1621    AssertReturn(cbToRead, VERR_INVALID_PARAMETER);
    16171622    AssertReturn(uOffset + cbToRead <= getImageDiskSize(&pImage->Header), VERR_INVALID_PARAMETER);
    16181623
    … …  
    16731678    Assert(!(uOffset % 512));
    16741679    Assert(!(cbToWrite % 512));
    1675     AssertReturn((VALID_PTR(pIoCtx) && cbToWrite), VERR_INVALID_PARAMETER);
     1680    AssertPtrReturn(pIoCtx, VERR_INVALID_POINTER);
     1681    AssertReturn(cbToWrite, VERR_INVALID_PARAMETER);
    16761682
    16771683    if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))

  • trunk/src/VBox/Storage/VHD.cpp

    r85121 r90802  
    13631363    /* Check open flags. All valid flags are supported. */
    13641364    AssertReturn(!(uOpenFlags & ~VD_OPEN_FLAGS_MASK), VERR_INVALID_PARAMETER);
    1365     AssertReturn((VALID_PTR(pszFilename) && *pszFilename), VERR_INVALID_PARAMETER);
     1365    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
     1366    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
     1367
    13661368
    13671369    PVHDIMAGE pImage = (PVHDIMAGE)RTMemAllocZ(RT_UOFFSETOF(VHDIMAGE, RegionList.aRegions[1]));
    … …  
    14071409    /* Check open flags. All valid flags are supported. */
    14081410    AssertReturn(!(uOpenFlags & ~VD_OPEN_FLAGS_MASK), VERR_INVALID_PARAMETER);
    1409     AssertReturn(   VALID_PTR(pszFilename)
    1410                  && *pszFilename
    1411                  && VALID_PTR(pPCHSGeometry)
    1412                  && VALID_PTR(pLCHSGeometry), VERR_INVALID_PARAMETER);
     1411    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
     1412    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
     1413    AssertPtrReturn(pPCHSGeometry, VERR_INVALID_POINTER);
     1414    AssertPtrReturn(pLCHSGeometry, VERR_INVALID_POINTER);
    14131415    /** @todo Check the values of other params */
    14141416
    … …  
    14231425        /* Get I/O interface. */
    14241426        pImage->pIfIo = VDIfIoIntGet(pImage->pVDIfsImage);
    1425         if (RT_LIKELY(VALID_PTR(pImage->pIfIo)))
     1427        if (RT_LIKELY(RT_VALID_PTR(pImage->pIfIo)))
    14261428        {
    14271429            rc = vhdCreateImage(pImage, cbSize, uImageFlags, pszComment,
    … …  
    15181520    Assert(uOffset % 512 == 0);
    15191521    Assert(cbToRead % 512 == 0);
    1520     AssertReturn((VALID_PTR(pIoCtx) && cbToRead), VERR_INVALID_PARAMETER);
     1522    AssertPtrReturn(pIoCtx, VERR_INVALID_POINTER);
     1523    AssertReturn(cbToRead, VERR_INVALID_PARAMETER);
    15211524    AssertReturn(uOffset + cbToRead <= pImage->cbSize, VERR_INVALID_PARAMETER);
    15221525
    … …  
    16391642    Assert(!(uOffset % VHD_SECTOR_SIZE));
    16401643    Assert(!(cbToWrite % VHD_SECTOR_SIZE));
    1641     AssertReturn((VALID_PTR(pIoCtx) && cbToWrite), VERR_INVALID_PARAMETER);
     1644    AssertPtrReturn(pIoCtx, VERR_INVALID_POINTER);
     1645    AssertReturn(cbToWrite, VERR_INVALID_PARAMETER);
    16421646    AssertReturn(uOffset + cbToWrite <= pImage->cbSize, VERR_INVALID_PARAMETER);
    16431647

  • trunk/src/VBox/Storage/VHDX.cpp

    r87917 r90802  
    17861786    AssertPtrReturn(pIfIo, VERR_INVALID_PARAMETER);
    17871787
    1788     if (   !VALID_PTR(pszFilename)
     1788    if (   !RT_VALID_PTR(pszFilename)
    17891789        || !*pszFilename)
    17901790        rc = VERR_INVALID_PARAMETER;
    … …  
    18431843    /* Check open flags. All valid flags are supported. */
    18441844    if (   uOpenFlags & ~VD_OPEN_FLAGS_MASK
    1845         || !VALID_PTR(pszFilename)
     1845        || !RT_VALID_PTR(pszFilename)
    18461846        || !*pszFilename)
    18471847        rc = VERR_INVALID_PARAMETER;

  • trunk/src/VBox/Storage/VMDK.cpp

    r87209 r90802  
    63086308    LogFlowFunc(("pszFilename=\"%s\" pVDIfsDisk=%#p pVDIfsImage=%#p penmType=%#p\n",
    63096309                 pszFilename, pVDIfsDisk, pVDIfsImage, penmType));
    6310     AssertReturn((VALID_PTR(pszFilename) && *pszFilename), VERR_INVALID_PARAMETER);
     6310    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
     6311    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
     6312
    63116313    int rc = VINF_SUCCESS;
    63126314    PVMDKIMAGE pImage = (PVMDKIMAGE)RTMemAllocZ(RT_UOFFSETOF(VMDKIMAGE, RegionList.aRegions[1]));
    … …  
    63456347    /* Check open flags. All valid flags are supported. */
    63466348    AssertReturn(!(uOpenFlags & ~VD_OPEN_FLAGS_MASK), VERR_INVALID_PARAMETER);
    6347     AssertReturn((VALID_PTR(pszFilename) && *pszFilename), VERR_INVALID_PARAMETER);
     6349    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
     6350    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
     6351
    63486352    PVMDKIMAGE pImage = (PVMDKIMAGE)RTMemAllocZ(RT_UOFFSETOF(VMDKIMAGE, RegionList.aRegions[1]));
    63496353    if (RT_LIKELY(pImage))
    … …  
    63966400    /* Check open flags. All valid flags are supported. */
    63976401    AssertReturn(!(uOpenFlags & ~VD_OPEN_FLAGS_MASK), VERR_INVALID_PARAMETER);
    6398     AssertReturn(   VALID_PTR(pszFilename)
    6399                  && *pszFilename
    6400                  && VALID_PTR(pPCHSGeometry)
    6401                  && VALID_PTR(pLCHSGeometry)
    6402                  && !(   uImageFlags & VD_VMDK_IMAGE_FLAGS_ESX
    6403                       && !(uImageFlags & VD_IMAGE_FLAGS_FIXED)),
     6402    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
     6403    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
     6404    AssertPtrReturn(pPCHSGeometry, VERR_INVALID_POINTER);
     6405    AssertPtrReturn(pLCHSGeometry, VERR_INVALID_POINTER);
     6406    AssertReturn(!(   uImageFlags & VD_VMDK_IMAGE_FLAGS_ESX
     6407                   && !(uImageFlags & VD_IMAGE_FLAGS_FIXED)),
    64046408                 VERR_INVALID_PARAMETER);
    64056409    PVMDKIMAGE pImage = (PVMDKIMAGE)RTMemAllocZ(RT_UOFFSETOF(VMDKIMAGE, RegionList.aRegions[1]));
    … …  
    67306734    memset(&RenameState, 0, sizeof(RenameState));
    67316735    /* Check arguments. */
    6732     AssertReturn((   pImage
    6733                   && VALID_PTR(pszFilename)
    6734                   && *pszFilename
    6735                   && !(pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_RAWDISK)), VERR_INVALID_PARAMETER);
     6736    AssertPtrReturn(pImage, VERR_INVALID_POINTER);
     6737    AssertPtrReturn(pszFilename, VERR_INVALID_POINTER);
     6738    AssertReturn(*pszFilename != '\0', VERR_INVALID_PARAMETER);
     6739    AssertReturn(!(pImage->uImageFlags & VD_VMDK_IMAGE_FLAGS_RAWDISK), VERR_INVALID_PARAMETER);
    67366740    int rc = vmdkRenameStatePrepare(pImage, &RenameState, pszFilename);
    67376741    if (RT_SUCCESS(rc))
    … …  
    67706774    Assert(uOffset % 512 == 0);
    67716775    Assert(cbToRead % 512 == 0);
    6772     AssertReturn((VALID_PTR(pIoCtx) && cbToRead), VERR_INVALID_PARAMETER);
     6776    AssertPtrReturn(pIoCtx, VERR_INVALID_POINTER);
     6777    AssertReturn(cbToRead, VERR_INVALID_PARAMETER);
    67736778    AssertReturn(uOffset + cbToRead <= pImage->cbSize, VERR_INVALID_PARAMETER);
    67746779    /* Find the extent and check access permissions as defined in the extent descriptor. */
    … …  
    68766881    Assert(uOffset % 512 == 0);
    68776882    Assert(cbToWrite % 512 == 0);
    6878     AssertReturn((VALID_PTR(pIoCtx) && cbToWrite), VERR_INVALID_PARAMETER);
     6883    AssertPtrReturn(pIoCtx, VERR_INVALID_POINTER);
     6884    AssertReturn(cbToWrite, VERR_INVALID_PARAMETER);
    68796885    if (!(pImage->uOpenFlags & VD_OPEN_FLAGS_READONLY))
    68806886    {

  • trunk/src/VBox/Storage/testcase/VDScriptInterp.cpp

    r82968 r90802  
    638638                pCtrl = (PVDSCRIPTINTERPCTRL)vdScriptStackGetUsed(&pThis->StackCtrl);
    639639            }
    640             AssertMsg(VALID_PTR(pCtrl), ("Incorrect program, return outside of function\n"));
     640            AssertMsg(RT_VALID_PTR(pCtrl), ("Incorrect program, return outside of function\n"));
    641641            break;
    642642        }
    … …  
    662662                pCtrl = (PVDSCRIPTINTERPCTRL)vdScriptStackGetUsed(&pThis->StackCtrl);
    663663            }
    664             AssertMsg(VALID_PTR(pCtrl), ("Incorrect program, continue outside of loop\n"));
     664            AssertMsg(RT_VALID_PTR(pCtrl), ("Incorrect program, continue outside of loop\n"));
    665665
    666666            /* Put the conditionals for while and for loops onto the control stack again. */
    … …  
    693693                pCtrl = (PVDSCRIPTINTERPCTRL)vdScriptStackGetUsed(&pThis->StackCtrl);
    694694            }
    695             AssertMsg(VALID_PTR(pCtrl), ("Incorrect program, break outside of loop\n"));
     695            AssertMsg(RT_VALID_PTR(pCtrl), ("Incorrect program, break outside of loop\n"));
    696696            vdScriptStackPop(&pThis->StackCtrl); /* Remove loop control statement. */
    697697            break;
Note: See TracChangeset for help on using the changeset viewer.

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