VirtualBox

Changeset 62963 in vbox


Ignore:
Timestamp:
Aug 4, 2016 9:24:53 AM (9 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
109566
Message:

Devices: warnings

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/Storage/DevAHCI.cpp

    r62632 r62963  
    313313    uint8_t                    aATAPICmd[ATAPI_PACKET_SIZE];
    314314    /** Size of one sector for the ATAPI transfer. */
    315     size_t                     cbATAPISector;
     315    uint32_t                   cbATAPISector;
    316316    /** Physical address of the command header. - GC */
    317317    RTGCPHYS                   GCPhysCmdHdrAddr;
    … …  
    958958static int  ahciPostFisIntoMemory(PAHCIPort pAhciPort, unsigned uFisType, uint8_t *cmdFis);
    959959static void ahciPostFirstD2HFisIntoMemory(PAHCIPort pAhciPort);
    960 static size_t ahciCopyToPrdtl(PPDMDEVINS pDevIns, PAHCIREQ pAhciReq,
    961                               void *pvBuf, size_t cbBuf);
    962 static size_t ahciCopyFromPrdtl(PPDMDEVINS pDevIns, PAHCIREQ pAhciReq,
    963                                 void *pvBuf, size_t cbBuf);
     960static uint32_t ahciCopyToPrdtl(PPDMDEVINS pDevIns, PAHCIREQ pAhciReq, const void *pvBuf, size_t cbBuf);
     961static size_t ahciCopyFromPrdtl(PPDMDEVINS pDevIns, PAHCIREQ pAhciReq, void *pvBuf, size_t cbBuf);
    964962static bool ahciCancelActiveTasks(PAHCIPort pAhciPort, PAHCIREQ pAhciReqExcept);
    965963static void ahciReqMemFree(PAHCIPort pAhciPort, PAHCIREQ pAhciReq, bool fForceFree);
    … …  
    10701068
    10711069#ifdef IN_RING3
     1070
    10721071/*
    10731072 * Assert irq when an CCC timeout occurs
    … …  
    10751074static DECLCALLBACK(void) ahciCccTimer(PPDMDEVINS pDevIns, PTMTIMER pTimer, void *pvUser)
    10761075{
     1076    RT_NOREF(pDevIns, pTimer);
    10771077    PAHCI pAhci = (PAHCI)pvUser;
    10781078
    … …  
    10911091    /* Cancel all tasks first. */
    10921092    bool fAllTasksCanceled = ahciCancelActiveTasks(pAhciPort, NULL);
    1093     Assert(fAllTasksCanceled);
     1093    Assert(fAllTasksCanceled); NOREF(fAllTasksCanceled);
    10941094
    10951095    /* Signature for SATA device. */
    … …  
    11371137    ASMAtomicXchgBool(&pAhciPort->fPortReset, false);
    11381138}
    1139 #endif
     1139
     1140#endif /* IN_RING3 */
    11401141
    11411142/**
    … …  
    12801281
    12811282        pAhciPort->regSSTS = 0;
    1282         pAhciPort->regSIG  = ~0;
     1283        pAhciPort->regSIG  = UINT32_MAX;
    12831284        pAhciPort->regTFD  = 0x7f;
    12841285        pAhciPort->fFirstD2HFisSend = false;
    … …  
    20772078
    20782079    pAhciPort->regTFD  = (1 << 8) | ATA_STAT_SEEK | ATA_STAT_WRERR;
    2079     pAhciPort->regSIG  = ~0;
     2080    pAhciPort->regSIG  = UINT32_MAX;
    20802081    pAhciPort->regSSTS = 0;
    20812082    pAhciPort->regSCTL = 0;
    … …  
    25482549#ifdef IN_RING3
    25492550
    2550 static DECLCALLBACK(int) ahciR3MMIOMap(PPCIDEVICE pPciDev, /*unsigned*/ int iRegion, RTGCPHYS GCPhysAddress, uint32_t cb,
    2551                                        PCIADDRESSSPACE enmType)
    2552 {
     2551static DECLCALLBACK(int)
     2552ahciR3MMIOMap(PPCIDEVICE pPciDev, /*unsigned*/ int iRegion, RTGCPHYS GCPhysAddress, uint32_t cb, PCIADDRESSSPACE enmType)
     2553{
     2554    RT_NOREF(iRegion, enmType);
    25532555    PAHCI pThis = PCIDEV_2_PAHCI(pPciDev);
    25542556    PPDMDEVINS pDevIns = pPciDev->pDevIns;
    … …  
    25902592 * Map the legacy I/O port ranges to make Solaris work with the controller.
    25912593 */
    2592 static DECLCALLBACK(int) ahciR3LegacyFakeIORangeMap(PPCIDEVICE pPciDev, /*unsigned*/ int iRegion, RTGCPHYS GCPhysAddress, uint32_t cb, PCIADDRESSSPACE enmType)
    2593 {
     2594static DECLCALLBACK(int)
     2595ahciR3LegacyFakeIORangeMap(PPCIDEVICE pPciDev, /*unsigned*/ int iRegion, RTGCPHYS GCPhysAddress, uint32_t cb, PCIADDRESSSPACE enmType)
     2596{
     2597    RT_NOREF(iRegion, enmType);
    25942598    PAHCI pThis = PCIDEV_2_PAHCI(pPciDev);
    25952599    PPDMDEVINS pDevIns = pPciDev->pDevIns;
    … …  
    26282632 * Map the BMDMA I/O port range (used for the Index/Data pair register access)
    26292633 */
    2630 static DECLCALLBACK(int) ahciR3IdxDataIORangeMap(PPCIDEVICE pPciDev, /*unsigned*/ int iRegion, RTGCPHYS GCPhysAddress, uint32_t cb, PCIADDRESSSPACE enmType)
    2631 {
     2634static DECLCALLBACK(int)
     2635ahciR3IdxDataIORangeMap(PPCIDEVICE pPciDev, /*unsigned*/ int iRegion, RTGCPHYS GCPhysAddress, uint32_t cb, PCIADDRESSSPACE enmType)
     2636{
     2637    RT_NOREF(iRegion, enmType);
    26322638    PAHCI pThis = PCIDEV_2_PAHCI(pPciDev);
    26332639    PPDMDEVINS pDevIns = pPciDev->pDevIns;
    … …  
    30833089static int ahciIdentifySS(PAHCIPort pAhciPort, void *pvBuf)
    30843090{
    3085     uint16_t *p;
    3086     int rc = VINF_SUCCESS;
    3087 
    3088     p = (uint16_t *)pvBuf;
     3091    uint16_t *p = (uint16_t *)pvBuf;
    30893092    memset(p, 0, 512);
    30903093    p[0] = RT_H2LE_U16(0x0040);
    … …  
    33013304
    33023305    /* Copy the buffer in to the scatter gather list. */
    3303     *pcbData =  ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq, (void *)&p[0],
    3304                                 RT_MIN(cbData, sizeof(p)));
     3306    *pcbData =  ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq, (void *)&p[0], RT_MIN(cbData, sizeof(p)));
    33053307
    33063308    atapiCmdOK(pAhciPort, pAhciReq);
    … …  
    33163318
    33173319    /* Copy the buffer in to the scatter gather list. */
    3318     *pcbData = ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq, (void *)&aBuf[0],
    3319                                RT_MIN(cbData, sizeof(aBuf)));
     3320    *pcbData = ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq, (void *)&aBuf[0], RT_MIN(cbData, sizeof(aBuf)));
    33203321
    33213322    atapiCmdOK(pAhciPort, pAhciReq);
    … …  
    33443345
    33453346    /* Copy the buffer in to the scatter gather list. */
    3346     *pcbData = ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq, (void *)&aBuf[0],
    3347                                RT_MIN(cbData, sizeof(aBuf)));
     3347    *pcbData = ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq, (void *)&aBuf[0], RT_MIN(cbData, sizeof(aBuf)));
    33483348
    33493349    atapiCmdOK(pAhciPort, pAhciReq);
    … …  
    33753375
    33763376    /* Copy the buffer in to the scatter gather list. */
    3377     *pcbData = ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq, (void *)&aBuf[0],
    3378                                RT_MIN(cbData, sizeof(aBuf)));
     3377    *pcbData = ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq, (void *)&aBuf[0], RT_MIN(cbData, sizeof(aBuf)));
    33793378
    33803379    atapiCmdOK(pAhciPort, pAhciReq);
    … …  
    33823381}
    33833382
    3384 static size_t atapiGetConfigurationFillFeatureListProfiles(PAHCIPort pAhciPort, uint8_t *pbBuf, size_t cbBuf)
     3383static size_t atapiGetConfigurationFillFeatureListProfiles(uint8_t *pbBuf, size_t cbBuf)
    33853384{
    33863385    if (cbBuf < 3*4)
    … …  
    34003399}
    34013400
    3402 static size_t atapiGetConfigurationFillFeatureCore(PAHCIPort pAhciPort, uint8_t *pbBuf, size_t cbBuf)
     3401static size_t atapiGetConfigurationFillFeatureCore(uint8_t *pbBuf, size_t cbBuf)
    34033402{
    34043403    if (cbBuf < 12)
    … …  
    34153414}
    34163415
    3417 static size_t atapiGetConfigurationFillFeatureMorphing(PAHCIPort pAhciPort, uint8_t *pbBuf, size_t cbBuf)
     3416static size_t atapiGetConfigurationFillFeatureMorphing(uint8_t *pbBuf, size_t cbBuf)
    34183417{
    34193418    if (cbBuf < 8)
    … …  
    34293428}
    34303429
    3431 static size_t atapiGetConfigurationFillFeatureRemovableMedium(PAHCIPort pAhciPort, uint8_t *pbBuf, size_t cbBuf)
     3430static size_t atapiGetConfigurationFillFeatureRemovableMedium(uint8_t *pbBuf, size_t cbBuf)
    34323431{
    34333432    if (cbBuf < 8)
    … …  
    34443443}
    34453444
    3446 static size_t atapiGetConfigurationFillFeatureRandomReadable(PAHCIPort pAhciPort, uint8_t *pbBuf, size_t cbBuf)
     3445static size_t atapiGetConfigurationFillFeatureRandomReadable(uint8_t *pbBuf, size_t cbBuf)
    34473446{
    34483447    if (cbBuf < 12)
    … …  
    34603459}
    34613460
    3462 static size_t atapiGetConfigurationFillFeatureCDRead(PAHCIPort pAhciPort, uint8_t *pbBuf, size_t cbBuf)
     3461static size_t atapiGetConfigurationFillFeatureCDRead(uint8_t *pbBuf, size_t cbBuf)
    34633462{
    34643463    if (cbBuf < 8)
    … …  
    34743473}
    34753474
    3476 static size_t atapiGetConfigurationFillFeaturePowerManagement(PAHCIPort pAhciPort, uint8_t *pbBuf, size_t cbBuf)
     3475static size_t atapiGetConfigurationFillFeaturePowerManagement(uint8_t *pbBuf, size_t cbBuf)
    34773476{
    34783477    if (cbBuf < 4)
    … …  
    34863485}
    34873486
    3488 static size_t atapiGetConfigurationFillFeatureTimeout(PAHCIPort pAhciPort, uint8_t *pbBuf, size_t cbBuf)
     3487static size_t atapiGetConfigurationFillFeatureTimeout(uint8_t *pbBuf, size_t cbBuf)
    34893488{
    34903489    if (cbBuf < 8)
    … …  
    35213520    pbBuf    += 8;
    35223521
    3523     cbCopied = atapiGetConfigurationFillFeatureListProfiles(pAhciPort, pbBuf, cbBuf);
     3522    cbCopied = atapiGetConfigurationFillFeatureListProfiles(pbBuf, cbBuf);
    35243523    cbBuf -= cbCopied;
    35253524    pbBuf += cbCopied;
    35263525
    3527     cbCopied = atapiGetConfigurationFillFeatureCore(pAhciPort, pbBuf, cbBuf);
     3526    cbCopied = atapiGetConfigurationFillFeatureCore(pbBuf, cbBuf);
    35283527    cbBuf -= cbCopied;
    35293528    pbBuf += cbCopied;
    35303529
    3531     cbCopied = atapiGetConfigurationFillFeatureMorphing(pAhciPort, pbBuf, cbBuf);
     3530    cbCopied = atapiGetConfigurationFillFeatureMorphing(pbBuf, cbBuf);
    35323531    cbBuf -= cbCopied;
    35333532    pbBuf += cbCopied;
    35343533
    3535     cbCopied = atapiGetConfigurationFillFeatureRemovableMedium(pAhciPort, pbBuf, cbBuf);
     3534    cbCopied = atapiGetConfigurationFillFeatureRemovableMedium(pbBuf, cbBuf);
    35363535    cbBuf -= cbCopied;
    35373536    pbBuf += cbCopied;
    35383537
    3539     cbCopied = atapiGetConfigurationFillFeatureRandomReadable(pAhciPort, pbBuf, cbBuf);
     3538    cbCopied = atapiGetConfigurationFillFeatureRandomReadable(pbBuf, cbBuf);
    35403539    cbBuf -= cbCopied;
    35413540    pbBuf += cbCopied;
    35423541
    3543     cbCopied = atapiGetConfigurationFillFeatureCDRead(pAhciPort, pbBuf, cbBuf);
     3542    cbCopied = atapiGetConfigurationFillFeatureCDRead(pbBuf, cbBuf);
    35443543    cbBuf -= cbCopied;
    35453544    pbBuf += cbCopied;
    35463545
    3547     cbCopied = atapiGetConfigurationFillFeaturePowerManagement(pAhciPort, pbBuf, cbBuf);
     3546    cbCopied = atapiGetConfigurationFillFeaturePowerManagement(pbBuf, cbBuf);
    35483547    cbBuf -= cbCopied;
    35493548    pbBuf += cbCopied;
    35503549
    3551     cbCopied = atapiGetConfigurationFillFeatureTimeout(pAhciPort, pbBuf, cbBuf);
     3550    cbCopied = atapiGetConfigurationFillFeatureTimeout(pbBuf, cbBuf);
    35523551    cbBuf -= cbCopied;
    35533552    pbBuf += cbCopied;
    35543553
    35553554    /* Set data length now. */
    3556     ataH2BE_U32(&aBuf[0], sizeof(aBuf) - cbBuf);
     3555    ataH2BE_U32(&aBuf[0], (uint32_t)(sizeof(aBuf) - cbBuf));
    35573556
    35583557    /* Copy the buffer in to the scatter gather list. */
    3559     *pcbData = ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq, (void *)&aBuf[0],
    3560                                RT_MIN(cbData, sizeof(aBuf)));
     3558    *pcbData = ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq, (void *)&aBuf[0], RT_MIN(cbData, sizeof(aBuf)));
    35613559
    35623560    atapiCmdOK(pAhciPort, pAhciReq);
    … …  
    36343632    } while (!ASMAtomicCmpXchgU32(&pAhciPort->MediaEventStatus, NewStatus, OldStatus));
    36353633
    3636     *pcbData = ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq, (void *)&abBuf[0],
    3637                                RT_MIN(cbData, sizeof(abBuf)));
     3634    *pcbData = ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq, (void *)&abBuf[0], RT_MIN(cbData, sizeof(abBuf)));
    36383635
    36393636    atapiCmdOK(pAhciPort, pAhciReq);
    … …  
    36593656
    36603657    /* Copy the buffer in to the scatter gather list. */
    3661     *pcbData = ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq, (void *)&aBuf[0],
    3662                                RT_MIN(cbData, sizeof(aBuf)));
     3658    *pcbData = ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq, (void *)&aBuf[0], RT_MIN(cbData, sizeof(aBuf)));
    36633659
    36643660    atapiCmdOK(pAhciPort, pAhciReq);
    … …  
    36893685
    36903686    /* Copy the buffer in to the scatter gather list. */
    3691     *pcbData = ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq, (void *)&aBuf[0],
    3692                                RT_MIN(cbData, sizeof(aBuf)));
     3687    *pcbData = ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq, (void *)&aBuf[0], RT_MIN(cbData, sizeof(aBuf)));
    36933688
    36943689    atapiCmdOK(pAhciPort, pAhciReq);
    … …  
    37403735
    37413736    /* Copy the buffer in to the scatter gather list. */
    3742     *pcbData = ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq, (void *)&aBuf[0],
    3743                                RT_MIN(cbData, sizeof(aBuf)));
     3737    *pcbData = ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq, (void *)&aBuf[0], RT_MIN(cbData, sizeof(aBuf)));
    37443738
    37453739    atapiCmdOK(pAhciPort, pAhciReq);
    … …  
    37723766
    37733767    /* Copy the buffer in to the scatter gather list. */
    3774     *pcbData = ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq, (void *)&aBuf[0],
    3775                                RT_MIN(cbData, sizeof(aBuf)));
     3768    *pcbData = ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq, (void *)&aBuf[0], RT_MIN(cbData, sizeof(aBuf)));
    37763769
    37773770    atapiCmdOK(pAhciPort, pAhciReq);
    … …  
    38353828
    38363829    /* Copy the buffer in to the scatter gather list. */
    3837     *pcbData = ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq, (void *)&aBuf[0],
    3838                                RT_MIN(cbData, cbSize));
     3830    *pcbData = ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq, (void *)&aBuf[0], RT_MIN(cbData, cbSize));
    38393831
    38403832    atapiCmdOK(pAhciPort, pAhciReq);
    … …  
    38693861
    38703862    /* Copy the buffer in to the scatter gather list. */
    3871     *pcbData = ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq, (void *)&aBuf[0],
    3872                                RT_MIN(cbData, sizeof(aBuf)));
     3863    *pcbData = ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq, (void *)&aBuf[0], RT_MIN(cbData, sizeof(aBuf)));
    38733864
    38743865    atapiCmdOK(pAhciPort, pAhciReq);
    … …  
    39583949
    39593950    /* Copy the buffer in to the scatter gather list. */
    3960     *pcbData = ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq, (void *)&aBuf[0],
    3961                                RT_MIN(cbData, cbSize));
     3951    *pcbData = ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq, (void *)&aBuf[0], RT_MIN(cbData, cbSize));
    39623952
    39633953    atapiCmdOK(pAhciPort, pAhciReq);
    … …  
    39753965static int atapiPassthroughSS(PAHCIREQ pAhciReq, PAHCIPort pAhciPort, size_t cbData, size_t *pcbData)
    39763966{
     3967    RT_NOREF(cbData);
    39773968    int rc = VINF_SUCCESS;
    39783969    uint8_t abATAPISense[ATAPI_SENSE_SIZE];
    … …  
    40124003         * imbalance of powers. */
    40134004        uint8_t aATAPICmd[ATAPI_PACKET_SIZE];
    4014         uint32_t iATAPILBA, cSectors, cReqSectors, cbCurrTX;
     4005        uint32_t iATAPILBA, cSectors;
    40154006        uint8_t *pbBuf = (uint8_t *)pvBuf;
    40164007
    … …  
    40454036        }
    40464037        memcpy(aATAPICmd, pAhciReq->aATAPICmd, ATAPI_PACKET_SIZE);
    4047         cReqSectors = 0;
     4038        uint32_t cReqSectors = 0;
    40484039        for (uint32_t i = cSectors; i > 0; i -= cReqSectors)
    40494040        {
    … …  
    40524043            else
    40534044                cReqSectors = i;
    4054             cbCurrTX = pAhciReq->cbATAPISector * cReqSectors;
     4045            uint32_t cbCurrTX = pAhciReq->cbATAPISector * cReqSectors;
    40554046            switch (pAhciReq->aATAPICmd[0])
    40564047            {
    … …  
    41794170
    41804171                /* Reply with the same amount of data as the real drive. */
    4181                 *pcbData = ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq, pvBuf,
    4182                                            cbTransfer);
     4172                *pcbData = ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq, pvBuf, cbTransfer);
    41834173            }
    41844174            else
    … …  
    43714361
    43724362    /* Copy the buffer into the scatter gather list. */
    4373     *pcbData = ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq, (void *)&aBuf[0],
    4374                                RT_MIN(cbData, max_len));
     4363    *pcbData = ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq, (void *)&aBuf[0], RT_MIN(cbData, max_len));
    43754364
    43764365    atapiCmdOK(pAhciPort, pAhciReq);
    … …  
    43814370{
    43824371    size_t cbTransfered = 0;
    4383     int rcSourceSink;
    4384 
    4385     rcSourceSink = g_apfnAtapiFuncs[iSourceSink](pAhciReq, pAhciPort, cbMax,
    4386                                                  &cbTransfered);
    4387 
    4388     pAhciReq->cmdHdr.u32PRDBC = cbTransfered;
    4389     pAhciReq->cbTransfer = cbTransfered;
     4372    int rcSourceSink = g_apfnAtapiFuncs[iSourceSink](pAhciReq, pAhciPort, cbMax, &cbTransfered);
     4373
     4374    pAhciReq->cmdHdr.u32PRDBC = (uint32_t)cbTransfered;
     4375    pAhciReq->cbTransfer      = (uint32_t)cbTransfered;
     4376    Assert(pAhciReq->cbTransfer == cbTransfered);
    43904377
    43914378    LogFlow(("cbTransfered=%d\n", cbTransfered));
    … …  
    44394426static int atapiReadSectors(PAHCIPort pAhciPort, PAHCIREQ pAhciReq, uint32_t iATAPILBA, uint32_t cSectors, uint32_t cbSector)
    44404427{
     4428    RT_NOREF(pAhciPort);
    44414429    Log(("%s: %d sectors at LBA %d\n", __FUNCTION__, cSectors, iATAPILBA));
    44424430
    … …  
    55575545 * @param   cbBuf          The size of the buffer.
    55585546 */
    5559 static size_t ahciCopyToPrdtl(PPDMDEVINS pDevIns, PAHCIREQ pAhciReq,
    5560                               void *pvBuf, size_t cbBuf)
    5561 {
    5562     uint8_t *pbBuf = (uint8_t *)pvBuf;
     5547static uint32_t ahciCopyToPrdtl(PPDMDEVINS pDevIns, PAHCIREQ pAhciReq, void const *pvBuf, size_t cbBuf)
     5548{
     5549    uint8_t const *pbBuf = (uint8_t const *)pvBuf;
    55635550    SGLEntry aPrdtlEntries[32];
    55645551    RTGCPHYS GCPhysPrdtl = pAhciReq->GCPhysPrdtl;
    55655552    unsigned cPrdtlEntries = pAhciReq->cPrdtlEntries;
    5566     size_t cbCopied = 0;
     5553    uint32_t cbCopied = 0;
    55675554
    55685555    AssertMsgReturn(cPrdtlEntries > 0, ("Copying 0 bytes is not possible\n"), 0);
    … …  
    55815568            uint32_t cbThisCopy = (aPrdtlEntries[i].u32DescInf & SGLENTRY_DESCINF_DBC) + 1;
    55825569
    5583             cbThisCopy = RT_MIN(cbThisCopy, cbBuf);
     5570            cbThisCopy = (uint32_t)RT_MIN(cbThisCopy, cbBuf);
    55845571
    55855572            /* Copy into SG entry. */
    … …  
    56345621            uint32_t cbThisCopy = (aPrdtlEntries[i].u32DescInf & SGLENTRY_DESCINF_DBC) + 1;
    56355622
    5636             cbThisCopy = RT_MIN(cbThisCopy, cbBuf);
     5623            cbThisCopy = (uint32_t)RT_MIN(cbThisCopy, cbBuf);
    56375624
    56385625            /* Copy into buffer. */
    … …  
    57145701        }
    57155702        else
    5716             ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq,
    5717                             pAhciReq->u.Io.DataSeg.pvSeg,
    5718                             pAhciReq->u.Io.DataSeg.cbSeg);
     5703            ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq, pAhciReq->u.Io.DataSeg.pvSeg, pAhciReq->u.Io.DataSeg.cbSeg);
    57195704    }
    57205705
    … …  
    62996284    AHCITXDIR enmTxDir = AHCITXDIR_NONE;
    63006285    bool fLBA48 = false;
    6301     CmdHdr   *pCmdHdr = &pAhciReq->cmdHdr;
    63026286
    63036287    AssertMsg(pCmdFis[AHCI_CMDFIS_TYPE] == AHCI_CMDFIS_TYPE_H2D, ("FIS is not a host to device Fis!!\n"));
    … …  
    63126296            {
    63136297                uint16_t u16Temp[256];
    6314                 size_t cbCopied;
    63156298
    63166299                /* Fill the buffer. */
    … …  
    63186301
    63196302                /* Copy the buffer. */
    6320                 cbCopied = ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq,
    6321                                            &u16Temp[0], sizeof(u16Temp));
     6303                uint32_t cbCopied = ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq, &u16Temp[0], sizeof(u16Temp));
    63226304
    63236305                pAhciReq->fFlags |= AHCI_REQ_PIO_DATA;
    … …  
    64866468            unsigned offLogRead = ((pCmdFis[AHCI_CMDFIS_CYLLEXP] << 8) | pCmdFis[AHCI_CMDFIS_CYLL]) * 512;
    64876469            unsigned iPage = pCmdFis[AHCI_CMDFIS_SECTN];
    6488             size_t cbCopied;
    64896470
    64906471            LogFlow(("Trying to read %zu bytes starting at offset %u from page %u\n", cbLogRead, offLogRead, iPage));
    … …  
    65406521                         */
    65416522                        bool fAbortedAll = ahciCancelActiveTasks(pAhciPort, pAhciReq);
    6542                         Assert(fAbortedAll);
     6523                        Assert(fAbortedAll); NOREF(fAbortedAll);
    65436524                        ahciSendSDBFis(pAhciPort, 0xffffffff, true);
    65446525
    … …  
    65486529
    65496530                /* Copy the buffer. */
    6550                 cbCopied = ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq,
    6551                                            &aBuf[offLogRead], cbLogRead);
     6531                uint32_t cbCopied = ahciCopyToPrdtl(pAhciPort->pDevInsR3, pAhciReq, &aBuf[offLogRead], cbLogRead);
    65526532
    65536533                pAhciReq->fFlags |= AHCI_REQ_PIO_DATA;
    … …  
    68816861static DECLCALLBACK(int) ahciAsyncIOLoop(PPDMDEVINS pDevIns, PPDMTHREAD pThread)
    68826862{
     6863    RT_NOREF(pDevIns);
    68836864    PAHCIPort pAhciPort = (PAHCIPort)pThread->pvUser;
    68846865    PAHCI     pAhci     = pAhciPort->CTX_SUFF(pAhci);
    6885     int rc = VINF_SUCCESS;
    6886     uint64_t u64StartTime = 0;
    6887     uint64_t u64StopTime  = 0;
    6888     uint32_t uIORequestsProcessed = 0;
    6889     uint32_t uIOsPerSec = 0;
    6890     uint32_t fTasksToProcess = 0;
     6866    int       rc        = VINF_SUCCESS;
    68916867
    68926868    ahciLog(("%s: Port %d entering async IO loop.\n", __FUNCTION__, pAhciPort->iLUN));
    … …  
    70707046static DECLCALLBACK(void) ahciR3Info(PPDMDEVINS pDevIns, PCDBGFINFOHLP pHlp, const char *pszArgs)
    70717047{
     7048    RT_NOREF(pszArgs);
    70727049    PAHCI pThis = PDMINS_2_DATA(pDevIns, PAHCI);
    70737050
    … …  
    71717148static DECLCALLBACK(int) ahciR3SavePrep(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
    71727149{
     7150    RT_NOREF(pDevIns, pSSM);
    71737151    Assert(ahciR3AllAsyncIOIsFinished(pDevIns));
    71747152    return VINF_SUCCESS;
    … …  
    71807158static DECLCALLBACK(int) ahciR3LoadPrep(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
    71817159{
     7160    RT_NOREF(pDevIns, pSSM);
    71827161    Assert(ahciR3AllAsyncIOIsFinished(pDevIns));
    71837162    return VINF_SUCCESS;
    … …  
    71897168static DECLCALLBACK(int) ahciR3LiveExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uPass)
    71907169{
     7170    RT_NOREF(uPass);
    71917171    PAHCI pThis = PDMINS_2_DATA(pDevIns, PAHCI);
    71927172
    … …  
    72037183
    72047184    static const char *s_apszIdeEmuPortNames[4] = { "PrimaryMaster", "PrimarySlave", "SecondaryMaster", "SecondarySlave" };
    7205     for (size_t i = 0; i < RT_ELEMENTS(s_apszIdeEmuPortNames); i++)
     7185    for (uint32_t i = 0; i < RT_ELEMENTS(s_apszIdeEmuPortNames); i++)
    72067186    {
    72077187        uint32_t iPort;
    … …  
    74397419
    74407420        static const char *s_apszIdeEmuPortNames[4] = { "PrimaryMaster", "PrimarySlave", "SecondaryMaster", "SecondarySlave" };
    7441         for (size_t i = 0; i < RT_ELEMENTS(s_apszIdeEmuPortNames); i++)
     7421        for (uint32_t i = 0; i < RT_ELEMENTS(s_apszIdeEmuPortNames); i++)
    74427422        {
    74437423            uint32_t iPort;
    … …  
    78987878static int ahciR3VpdInit(PPDMDEVINS pDevIns, PAHCIPort pAhciPort, const char *pszName)
    78997879{
    7900     int rc = VINF_SUCCESS;
    7901     PAHCI pAhci = PDMINS_2_DATA(pDevIns, PAHCI);
    79027880
    79037881    /* Generate a default serial number. */
    … …  
    79057883    RTUUID Uuid;
    79067884
     7885    int rc = VINF_SUCCESS;
    79077886    if (pAhciPort->pDrvMedia)
    79087887        rc = pAhciPort->pDrvMedia->pfnGetUuid(pAhciPort->pDrvMedia, &Uuid);
    … …  
    82098188static int ahciR3ResetCommon(PPDMDEVINS pDevIns, bool fConstructor)
    82108189{
     8190    RT_NOREF(fConstructor);
    82118191    PAHCI pAhci = PDMINS_2_DATA(pDevIns, PAHCI);
    82128192
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