VirtualBox

Changeset 80589 in vbox


Ignore:
Timestamp:
Sep 4, 2019 6:20:28 PM (5 years ago)
Author:
vboxsync
Message:

Devices/Storage: Add two new parameters to PDMIMEDIAEX::pfnIoReqSendScsiCmd to return the amount ofsense data written and the determined transfer direction from parsed CDB, bugref:9440

Location:
trunk
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/VBox/vmm/pdmstorageifs.h

    r76585 r80589  
    950950     * @param   cbCdb           Size of the CDB in bytes.
    951951     * @param   enmTxDir        Direction of transfer.
     952     * @param   penmTxDir       Where to store the transfer direction as parsed from the CDB, optional.
    952953     * @param   cbBuf           Size of the transfer buffer.
    953954     * @param   pabSense        Where to store the optional sense key.
    954955     * @param   cbSense         Size of the sense key buffer.
     956     * @param   pcbSense        Where to store the amount of sense data written, optional.
    955957     * @param   pu8ScsiSts      Where to store the SCSI status on success.
    956958     * @param   cTimeoutMillies Command timeout in milliseconds.
    957959     * @thread  Any thread.
    958960     */
    959     DECLR3CALLBACKMEMBER(int, pfnIoReqSendScsiCmd,(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq, uint32_t uLun,
    960                                                    const uint8_t *pbCdb, size_t cbCdb, PDMMEDIAEXIOREQSCSITXDIR enmTxDir,
    961                                                    size_t cbBuf, uint8_t *pabSense, size_t cbSense, uint8_t *pu8ScsiSts,
    962                                                    uint32_t cTimeoutMillies));
     961    DECLR3CALLBACKMEMBER(int, pfnIoReqSendScsiCmd,(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq,
     962                                                   uint32_t uLun, const uint8_t *pbCdb, size_t cbCdb,
     963                                                   PDMMEDIAEXIOREQSCSITXDIR enmTxDir, PDMMEDIAEXIOREQSCSITXDIR *penmTxDirRet,
     964                                                   size_t cbBuf, uint8_t *pabSense, size_t cbSense, size_t *pcbSenseRet,
     965                                                   uint8_t *pu8ScsiSts, uint32_t cTimeoutMillies));
    963966
    964967    /**
    … …  
    10361039} PDMIMEDIAEX;
    10371040/** PDMIMEDIAEX interface ID. */
    1038 #define PDMIMEDIAEX_IID                      "1f82b709-a9f7-4928-ad50-e879c9bbeba1"
     1041#define PDMIMEDIAEX_IID                      "29c9e82b-934e-45c5-bb84-0d871c3cc9dd"
    10391042
    10401043/** @} */

  • trunk/include/VBox/vscsi.h

    r76585 r80589  
    8787
    8888/**
     89 * Virtual SCSI transfer direction as seen from the initiator.
     90 */
     91typedef enum VSCSIXFERDIR
     92{
     93    /** Invalid data direction. */
     94    PVSCSIXFERDIR_INVALID     = 0,
     95    /** Direction is unknown. */
     96    VSCSIXFERDIR_UNKNOWN,
     97    /** Direction is from target to initiator (aka a read). */
     98    VSCSIXFERDIR_T2I,
     99    /** Direction is from initiator to device (aka a write). */
     100    VSCSIXFERDIR_I2T,
     101    /** No data transfer associated with this request. */
     102    VSCSIXFERDIR_NONE,
     103    /** 32bit hack. */
     104    VSCSIXFERDIR_32BIT_HACK  = 0x7fffffff
     105} VSCSIXFERDIR;
     106
     107/**
    89108 * LUN types we support
    90109 */
    … …  
    277296                                               bool fRedoPossible,
    278297                                               int rcReq,
    279                                                size_t cbXfer);
     298                                               size_t cbXfer,
     299                                               VSCSIXFERDIR enmXferDir,
     300                                               size_t cbSense);
    280301/** Pointer to a virtual SCSI request completed callback. */
    281302typedef FNVSCSIREQCOMPLETED *PFNVSCSIREQCOMPLETED;

  • trunk/src/VBox/Devices/Samples/DrvStorageFilter.cpp

    r76553 r80589  
    337337
    338338/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqSendScsiCmd} */
    339 static DECLCALLBACK(int) drvStorageFltIMedia_IoReqSendScsiCmd(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq, uint32_t uLun,
    340                                                               const uint8_t *pbCdb, size_t cbCdb, PDMMEDIAEXIOREQSCSITXDIR enmTxDir,
    341                                                               size_t cbBuf, uint8_t *pabSense, size_t cbSense, uint8_t *pu8ScsiSts,
    342                                                               uint32_t cTimeoutMillies)
     339static DECLCALLBACK(int) drvStorageFltIMedia_IoReqSendScsiCmd(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq,
     340                                                              uint32_t uLun, const uint8_t *pbCdb, size_t cbCdb,
     341                                                              PDMMEDIAEXIOREQSCSITXDIR enmTxDir, PDMMEDIAEXIOREQSCSITXDIR *penmTxDirRet,
     342                                                              size_t cbBuf, uint8_t *pabSense, size_t cbSense, size_t *pcbSenseRet,
     343                                                              uint8_t *pu8ScsiSts, uint32_t cTimeoutMillies)
    343344{
    344345    PDRVSTORAGEFILTER pThis = RT_FROM_MEMBER(pInterface, DRVSTORAGEFILTER, IMediaEx);
    345346    return pThis->pIMediaExBelow->pfnIoReqSendScsiCmd(pThis->pIMediaExBelow, hIoReq, uLun, pbCdb, cbCdb,
    346                                                       enmTxDir, cbBuf, pabSense, cbSense, pu8ScsiSts,
    347                                                       cTimeoutMillies);
     347                                                      enmTxDir, penmTxDirRet, cbBuf, pabSense, cbSense, pcbSenseRet,
     348                                                      pu8ScsiSts, cTimeoutMillies);
    348349}
    349350

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

    r80531 r80589  
    45014501            rc = pAhciPort->pDrvMediaEx->pfnIoReqSendScsiCmd(pAhciPort->pDrvMediaEx, pAhciReq->hIoReq,
    45024502                                                             0, &pAhciReq->aATAPICmd[0], ATAPI_PACKET_SIZE,
    4503                                                              PDMMEDIAEXIOREQSCSITXDIR_UNKNOWN, cbBuf,
    4504                                                              &pAhciPort->abATAPISense[0], sizeof(pAhciPort->abATAPISense),
     4503                                                             PDMMEDIAEXIOREQSCSITXDIR_UNKNOWN, NULL, cbBuf,
     4504                                                             &pAhciPort->abATAPISense[0], sizeof(pAhciPort->abATAPISense), NULL,
    45054505                                                             &pAhciReq->u8ScsiSts, 30 * RT_MS_1SEC);
    45064506        }

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

    r80531 r80589  
    27542754
    27552755        rc = pTgtDev->pDrvMediaEx->pfnIoReqSendScsiCmd(pTgtDev->pDrvMediaEx, pReq->hIoReq, uLun,
    2756                                                        pbCdb, cbCdb, PDMMEDIAEXIOREQSCSITXDIR_UNKNOWN,
    2757                                                        cbBuf, NULL, 0, &pReq->u8ScsiSts, 30 * RT_MS_1SEC);
     2756                                                       pbCdb, cbCdb, PDMMEDIAEXIOREQSCSITXDIR_UNKNOWN, NULL,
     2757                                                       cbBuf, NULL, 0, NULL, &pReq->u8ScsiSts, 30 * RT_MS_1SEC);
    27582758        if (rc == VINF_SUCCESS || rc != VINF_PDM_MEDIAEX_IOREQ_IN_PROGRESS)
    27592759        {
    … …  
    32823282                rc = pTgtDev->pDrvMediaEx->pfnIoReqSendScsiCmd(pTgtDev->pDrvMediaEx, pReq->hIoReq, uLun,
    32833283                                                               &pReq->CCBGuest.c.abCDB[0], pReq->CCBGuest.c.cbCDB,
    3284                                                                enmXferDir, cbBuf, pReq->pbSenseBuffer, cbSense,
     3284                                                               enmXferDir, NULL, cbBuf, pReq->pbSenseBuffer, cbSense, NULL,
    32853285                                                               &pReq->u8ScsiSts, 30 * RT_MS_1SEC);
    32863286                if (rc != VINF_PDM_MEDIAEX_IOREQ_IN_PROGRESS)

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

    r80531 r80589  
    22752275                rc = pTgtDev->pDrvMediaEx->pfnIoReqSendScsiCmd(pTgtDev->pDrvMediaEx, pLsiReq->hIoReq, pLsiReq->GuestRequest.SCSIIO.au8LUN[1],
    22762276                                                               &pLsiReq->GuestRequest.SCSIIO.au8CDB[0], pLsiReq->GuestRequest.SCSIIO.u8CDBLength,
    2277                                                                enmXferDir, pLsiReq->GuestRequest.SCSIIO.u32DataLength,
    2278                                                                &pLsiReq->abSenseBuffer[0], sizeof(pLsiReq->abSenseBuffer), &pLsiReq->u8ScsiSts,
    2279                                                                30 * RT_MS_1SEC);
     2277                                                               enmXferDir, NULL, pLsiReq->GuestRequest.SCSIIO.u32DataLength,
     2278                                                               &pLsiReq->abSenseBuffer[0], sizeof(pLsiReq->abSenseBuffer), NULL,
     2279                                                               &pLsiReq->u8ScsiSts, 30 * RT_MS_1SEC);
    22802280                if (rc != VINF_PDM_MEDIAEX_IOREQ_IN_PROGRESS)
    22812281                    lsilogicR3ReqComplete(pThis, pLsiReq, rc);
    … …  
    39053905
    39063906        rc = pTgtDev->pDrvMediaEx->pfnIoReqSendScsiCmd(pTgtDev->pDrvMediaEx, pReq->hIoReq, uLun,
    3907                                                        pbCdb, cbCdb, PDMMEDIAEXIOREQSCSITXDIR_UNKNOWN,
    3908                                                        cbBuf, NULL, 0, &pReq->u8ScsiSts, 30 * RT_MS_1SEC);
     3907                                                       pbCdb, cbCdb, PDMMEDIAEXIOREQSCSITXDIR_UNKNOWN, NULL,
     3908                                                       cbBuf, NULL, 0, NULL, &pReq->u8ScsiSts, 30 * RT_MS_1SEC);
    39093909        if (rc == VINF_SUCCESS || rc != VINF_PDM_MEDIAEX_IOREQ_IN_PROGRESS)
    39103910        {

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

    r80577 r80589  
    10921092    rc = pIMediaEx->pfnIoReqSendScsiCmd(pIMediaEx, pReq->hIoReq, uLUN,
    10931093                                        pVirtqReq->uCdb, pThis->virtioScsiConfig.uCdbSize,
    1094                                         PDMMEDIAEXIOREQSCSITXDIR_UNKNOWN, cbDataIn,
    1095                                         pReq->pbSense, pReq->cbSense,
     1094                                        PDMMEDIAEXIOREQSCSITXDIR_UNKNOWN, NULL, cbDataIn,
     1095                                        pReq->pbSense, pReq->cbSense, NULL,
    10961096                                        &pReq->uStatus, 30 * RT_MS_1SEC);
    10971097

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

    r76553 r80589  
    190190
    191191/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqSendScsiCmd} */
    192 static DECLCALLBACK(int) drvHostDvdIoReqSendScsiCmd(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq, uint32_t uLun,
    193                                                     const uint8_t *pbCdb, size_t cbCdb, PDMMEDIAEXIOREQSCSITXDIR enmTxDir,
    194                                                     size_t cbBuf, uint8_t *pabSense, size_t cbSense, uint8_t *pu8ScsiSts,
    195                                                     uint32_t cTimeoutMillies)
     192static DECLCALLBACK(int) drvHostDvdIoReqSendScsiCmd(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq,
     193                                                    uint32_t uLun, const uint8_t *pbCdb, size_t cbCdb,
     194                                                    PDMMEDIAEXIOREQSCSITXDIR enmTxDir, PDMMEDIAEXIOREQSCSITXDIR *penmTxDirRet,
     195                                                    size_t cbBuf, uint8_t *pabSense, size_t cbSense, size_t *pcbSenseRet,
     196                                                    uint8_t *pu8ScsiSts, uint32_t cTimeoutMillies)
    196197{
    197198    RT_NOREF3(uLun, cTimeoutMillies, enmTxDir);
    … …  
    409410        && VALID_PTR(pabSense)
    410411        && cbSense > 0)
    411         memcpy(pabSense, &pThis->abATAPISense[0], RT_MIN(cbSense, sizeof(pThis->abATAPISense)));
     412    {
     413        size_t cbSenseCpy = RT_MIN(cbSense, sizeof(pThis->abATAPISense));
     414
     415        memcpy(pabSense, &pThis->abATAPISense[0], cbSenseCpy);
     416        if (pcbSenseRet)
     417            *pcbSenseRet = cbSenseCpy;
     418    }
     419
     420    if (penmTxDirRet)
     421    {
     422        switch (enmXferDir)
     423        {
     424            case PDMMEDIATXDIR_NONE:
     425                *penmTxDirRet = PDMMEDIAEXIOREQSCSITXDIR_NONE;
     426                break;
     427            case PDMMEDIATXDIR_FROM_DEVICE:
     428                *penmTxDirRet = PDMMEDIAEXIOREQSCSITXDIR_FROM_DEVICE;
     429                break;
     430            case PDMMEDIATXDIR_TO_DEVICE:
     431                *penmTxDirRet = PDMMEDIAEXIOREQSCSITXDIR_TO_DEVICE;
     432                break;
     433            default:
     434                *penmTxDirRet = PDMMEDIAEXIOREQSCSITXDIR_UNKNOWN;
     435        }
     436    }
    412437
    413438    RTCritSectLeave(&pThis->Core.CritSect);

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

    r78796 r80589  
    7373    /** Where to store the SCSI status code. */
    7474    uint8_t                  *pu8ScsiSts;
     75    /** Where to store the amount of sense data written, optional. */
     76    size_t                   *pcbSense;
     77    /** Where to store the transfer direction determined by the VSCSI layer, optional. */
     78    PDMMEDIAEXIOREQSCSITXDIR *penmXferDir;
    7579    /** Transfer size determined by the VSCSI layer. */
    7680    size_t                   cbXfer;
    … …  
    170174}
    171175
     176
     177/**
     178 * Converts the given VSCSI transfer direction enum to the appropriate PDM extended media interface one.
     179 *
     180 * @returns The PDM extended media interface transfer direction.
     181 * @param   enmVScsiXferDir     The VSCSI transfer direction.
     182 */
     183static PDMMEDIAEXIOREQSCSITXDIR drvscsiVScsiXferDir2PdmMediaExDir(VSCSIXFERDIR enmVScsiXferDir)
     184{
     185    switch (enmVScsiXferDir)
     186    {
     187        case VSCSIXFERDIR_UNKNOWN: return PDMMEDIAEXIOREQSCSITXDIR_UNKNOWN;
     188        case VSCSIXFERDIR_T2I:     return PDMMEDIAEXIOREQSCSITXDIR_FROM_DEVICE;
     189        case VSCSIXFERDIR_I2T:     return PDMMEDIAEXIOREQSCSITXDIR_TO_DEVICE;
     190        case VSCSIXFERDIR_NONE:    return PDMMEDIAEXIOREQSCSITXDIR_NONE;
     191        default:                   return PDMMEDIAEXIOREQSCSITXDIR_INVALID;
     192    }
     193
     194    return PDMMEDIAEXIOREQSCSITXDIR_INVALID;
     195}
     196
     197
    172198/* -=-=-=-=- VScsiIoCallbacks -=-=-=-=- */
    173199
    … …  
    881907
    882908/** @interface_method_impl{PDMIMEDIAEX,pfnIoReqSendScsiCmd} */
    883 static DECLCALLBACK(int) drvscsiIoReqSendScsiCmd(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq, uint32_t uLun,
    884                                                  const uint8_t *pbCdb, size_t cbCdb, PDMMEDIAEXIOREQSCSITXDIR enmTxDir,
    885                                                  size_t cbBuf, uint8_t *pabSense, size_t cbSense, uint8_t *pu8ScsiSts,
    886                                                  uint32_t cTimeoutMillies)
     909static DECLCALLBACK(int) drvscsiIoReqSendScsiCmd(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq,
     910                                                 uint32_t uLun, const uint8_t *pbCdb, size_t cbCdb,
     911                                                 PDMMEDIAEXIOREQSCSITXDIR enmTxDir, PDMMEDIAEXIOREQSCSITXDIR *penmTxDirRet,
     912                                                 size_t cbBuf, uint8_t *pabSense, size_t cbSense, size_t *pcbSenseRet,
     913                                                 uint8_t *pu8ScsiSts, uint32_t cTimeoutMillies)
    887914{
    888915    RT_NOREF1(cTimeoutMillies);
    … …  
    898925    Log(("cbBuf=%zu\n", cbBuf));
    899926
    900     pReq->enmXferDir = enmTxDir;
    901     pReq->cbBuf      = cbBuf;
    902     pReq->pu8ScsiSts = pu8ScsiSts;
     927    pReq->enmXferDir   = enmTxDir;
     928    pReq->cbBuf        = cbBuf;
     929    pReq->pu8ScsiSts   = pu8ScsiSts;
     930    pReq->pcbSense     = pcbSenseRet;
     931    pReq->penmXferDir  = penmTxDirRet;
    903932
    904933    /* Allocate and sync buffers if a data transfer is indicated. */
    … …  
    9891018static DECLCALLBACK(void) drvscsiIoReqVScsiReqCompleted(VSCSIDEVICE hVScsiDevice, void *pVScsiDeviceUser,
    9901019                                                        void *pVScsiReqUser, int rcScsiCode, bool fRedoPossible,
    991                                                         int rcReq, size_t cbXfer)
     1020                                                        int rcReq, size_t cbXfer, VSCSIXFERDIR enmXferDir, size_t cbSense)
    9921021{
    9931022    RT_NOREF2(hVScsiDevice, fRedoPossible);
    … …  
    10191048    *pReq->pu8ScsiSts = (uint8_t)rcScsiCode;
    10201049    pReq->cbXfer      = cbXfer;
     1050    if (pReq->pcbSense)
     1051        *pReq->pcbSense = cbSense;
     1052    if (pReq->penmXferDir)
     1053        *pReq->penmXferDir = drvscsiVScsiXferDir2PdmMediaExDir(enmXferDir);
    10211054    int rc = pThis->pDevMediaExPort->pfnIoReqCompleteNotify(pThis->pDevMediaExPort, (PDMMEDIAEXIOREQ)pReq,
    10221055                                                            &pReq->abAlloc[0], rcReq);

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

    r80074 r80589  
    36313631 * @interface_method_impl{PDMIMEDIAEX,pfnIoReqSendScsiCmd}
    36323632 */
    3633 static DECLCALLBACK(int) drvvdIoReqSendScsiCmd(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq, uint32_t uLun,
    3634                                                const uint8_t *pbCdb, size_t cbCdb, PDMMEDIAEXIOREQSCSITXDIR enmTxDir,
    3635                                                size_t cbBuf, uint8_t *pabSense, size_t cbSense, uint8_t *pu8ScsiSts,
    3636                                                uint32_t cTimeoutMillies)
     3633static DECLCALLBACK(int) drvvdIoReqSendScsiCmd(PPDMIMEDIAEX pInterface, PDMMEDIAEXIOREQ hIoReq,
     3634                                               uint32_t uLun, const uint8_t *pbCdb, size_t cbCdb,
     3635                                               PDMMEDIAEXIOREQSCSITXDIR enmTxDir, PDMMEDIAEXIOREQSCSITXDIR *penmTxDirRet,
     3636                                               size_t cbBuf, uint8_t *pabSense, size_t cbSense, size_t *pcbSenseRet,
     3637                                               uint8_t *pu8ScsiSts, uint32_t cTimeoutMillies)
    36373638{
    36383639    RT_NOREF10(pInterface, uLun, pbCdb, cbCdb, enmTxDir, cbBuf, pabSense, cbSense, pu8ScsiSts, cTimeoutMillies);

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

    r76553 r80589  
    15611561
    15621562    return pThis->Lun0.pIMediaEx->pfnIoReqSendScsiCmd(pThis->Lun0.pIMediaEx, pReq->hIoReq, pReq->Cbw.bCBWLun,
    1563                                                       &pReq->Cbw.CBWCB[0], pReq->Cbw.bCBWCBLength, enmTxDir,
    1564                                                       pReq->Cbw.dCBWDataTransferLength, NULL, 0,
     1563                                                      &pReq->Cbw.CBWCB[0], pReq->Cbw.bCBWCBLength, enmTxDir, NULL,
     1564                                                      pReq->Cbw.dCBWDataTransferLength, NULL, 0, NULL,
    15651565                                                      &pReq->iScsiReqStatus, 20 * RT_MS_1SEC);
    15661566}

  • trunk/src/VBox/Devices/Storage/VSCSI/VSCSIDevice.cpp

    r80541 r80589  
    6767                SCSIINQUIRYDATA ScsiInquiryReply;
    6868
     69                vscsiReqSetXferDir(pVScsiReq, VSCSIXFERDIR_T2I);
    6970                vscsiReqSetXferSize(pVScsiReq, RT_MIN(sizeof(SCSIINQUIRYDATA), scsiBE2H_U16(&pVScsiReq->pbCDB[3])));
    7071                memset(&ScsiInquiryReply, 0, sizeof(ScsiInquiryReply));
    … …  
    8687             * to return an error.
    8788             */
     89            vscsiReqSetXferDir(pVScsiReq, VSCSIXFERDIR_T2I);
    8890            vscsiReqSetXferSize(pVScsiReq, scsiBE2H_U32(&pVScsiReq->pbCDB[6]));
    8991            if (pVScsiReq->cbXfer < 16)
    … …  
    106108        case SCSI_TEST_UNIT_READY:
    107109        {
     110            vscsiReqSetXferDir(pVScsiReq, VSCSIXFERDIR_NONE);
    108111            if (   vscsiDeviceLunIsPresent(pVScsiDevice, pVScsiReq->iLun)
    109112                && pVScsiDevice->papVScsiLun[pVScsiReq->iLun]->fReady)
    … …  
    115118        case SCSI_REQUEST_SENSE:
    116119        {
     120            vscsiReqSetXferDir(pVScsiReq, VSCSIXFERDIR_T2I);
    117121            vscsiReqSetXferSize(pVScsiReq, pVScsiReq->pbCDB[4]);
    118122
    … …  
    183187    pVScsiDevice->pfnVScsiReqCompleted(pVScsiDevice, pVScsiDevice->pvVScsiDeviceUser,
    184188                                       pVScsiReq->pvVScsiReqUser, rcScsiCode, fRedoPossible,
    185                                        rcReq, pVScsiReq->cbXfer);
     189                                       rcReq, pVScsiReq->cbXfer, pVScsiReq->enmXferDir, pVScsiReq->cbSenseWritten);
    186190
    187191    if (pVScsiReq->pvLun)
    … …  
    411415    pVScsiReq->cbXfer         = 0;
    412416    pVScsiReq->pvLun          = NULL;
     417    pVScsiReq->enmXferDir     = VSCSIXFERDIR_UNKNOWN;
     418    pVScsiReq->cbSenseWritten = 0;
    413419    RTSgBufInit(&pVScsiReq->SgBuf, paSGList, cSGListEntries);
    414420

  • trunk/src/VBox/Devices/Storage/VSCSI/VSCSIInternal.h

    r76565 r80589  
    126126    /** Transfer size determined from the CDB. */
    127127    size_t               cbXfer;
     128    /** Number of bytes of sense data written. */
     129    size_t               cbSenseWritten;
     130    /** Transfer direction as indicated by the CDB. */
     131    VSCSIXFERDIR         enmXferDir;
    128132    /** Pointer to the opaque data which may be allocated by the LUN
    129133     * the request is for. */
    … …  
    491495
    492496/**
     497 * Sets the transfer direction for the given request.
     498 *
     499 * @returns nothing.
     500 * @param   pVScsiReq     The SCSI request.
     501 * @param   cbXfer        The transfer size for the request.
     502 */
     503DECLINLINE(void) vscsiReqSetXferDir(PVSCSIREQINT pVScsiReq, VSCSIXFERDIR enmXferDir)
     504{
     505    pVScsiReq->enmXferDir = enmXferDir;
     506}
     507
     508/**
    493509 * Wrapper for the set I/O request allocation size I/O callback.
    494510 *

  • trunk/src/VBox/Devices/Storage/VSCSI/VSCSILunMmc.cpp

    r80541 r80589  
    10861086            case SCSI_TEST_UNIT_READY:
    10871087                Assert(!pVScsiLunMmc->Core.fReady); /* Only should get here if LUN isn't ready. */
     1088                vscsiReqSetXferDir(pVScsiReq, VSCSIXFERDIR_NONE);
    10881089                rcReq = vscsiLunReqSenseErrorSet(pVScsiLun, pVScsiReq, SCSI_SENSE_NOT_READY, SCSI_ASC_MEDIUM_NOT_PRESENT, 0x00);
    10891090                break;
    … …  
    10931094                SCSIINQUIRYDATA ScsiInquiryReply;
    10941095
     1096                vscsiReqSetXferDir(pVScsiReq, VSCSIXFERDIR_T2I);
    10951097                vscsiReqSetXferSize(pVScsiReq, RT_MIN(sizeof(SCSIINQUIRYDATA), scsiBE2H_U16(&pVScsiReq->pbCDB[3])));
    10961098                memset(&ScsiInquiryReply, 0, sizeof(ScsiInquiryReply));
    … …  
    11221124                uint8_t aReply[8];
    11231125                memset(aReply, 0, sizeof(aReply));
     1126                vscsiReqSetXferDir(pVScsiReq, VSCSIXFERDIR_T2I);
    11241127                vscsiReqSetXferSize(pVScsiReq, sizeof(aReply));
    11251128
    … …  
    11441147                bool    fValid = false;
    11451148
     1149                vscsiReqSetXferDir(pVScsiReq, VSCSIXFERDIR_T2I);
    11461150                vscsiReqSetXferSize(pVScsiReq, pVScsiReq->pbCDB[4]);
    11471151                memset(aReply, 0, sizeof(aReply));
    … …  
    11761180            {
    11771181                size_t cbMax = scsiBE2H_U16(&pVScsiReq->pbCDB[7]);
     1182                vscsiReqSetXferDir(pVScsiReq, VSCSIXFERDIR_T2I);
    11781183                vscsiReqSetXferSize(pVScsiReq, cbMax);
    11791184                rcReq = vscsiLunMmcModeSense10(pVScsiLunMmc, pVScsiReq, cbMax);
    … …  
    11831188            {
    11841189                uint32_t uLba = scsiBE2H_U32(&pVScsiReq->pbCDB[2]);
     1190
     1191                vscsiReqSetXferDir(pVScsiReq, VSCSIXFERDIR_NONE);
    11851192                if (uLba > pVScsiLunMmc->cSectors)
    11861193                    rcReq = vscsiLunReqSenseErrorSet(pVScsiLun, pVScsiReq, SCSI_SENSE_ILLEGAL_REQUEST,
    … …  
    11931200            {
    11941201                /** @todo implement!! */
     1202                vscsiReqSetXferDir(pVScsiReq, VSCSIXFERDIR_I2T);
    11951203                vscsiReqSetXferSize(pVScsiReq, pVScsiReq->pbCDB[4]);
    11961204                rcReq = vscsiLunReqSenseOkSet(pVScsiLun, pVScsiReq);
    … …  
    13941402                uint8_t uDataMode = pVScsiReq->pbCDB[1] & 0x1f;
    13951403
     1404                vscsiReqSetXferDir(pVScsiReq, VSCSIXFERDIR_T2I);
    13961405                vscsiReqSetXferSize(pVScsiReq, scsiBE2H_U16(&pVScsiReq->pbCDB[6]));
    13971406
    … …  
    14251434            {
    14261435                int rc2 = VINF_SUCCESS;
     1436
     1437                vscsiReqSetXferDir(pVScsiReq, VSCSIXFERDIR_NONE);
    14271438                switch (pVScsiReq->pbCDB[4] & 3)
    14281439                {
    … …  
    14481459                uint8_t uSubPageCode = pVScsiReq->pbCDB[3];
    14491460
     1461                vscsiReqSetXferDir(pVScsiReq, VSCSIXFERDIR_T2I);
    14501462                vscsiReqSetXferSize(pVScsiReq, scsiBE2H_U16(&pVScsiReq->pbCDB[7]));
    14511463
    … …  
    14871499                        /* Leave the rest 0 */
    14881500
     1501                        vscsiReqSetXferDir(pVScsiReq, VSCSIXFERDIR_T2I);
    14891502                        vscsiReqSetXferSize(pVScsiReq, sizeof(aReply));
    14901503                        RTSgBufCopyFromBuf(&pVScsiReq->SgBuf, aReply, sizeof(aReply));
    … …  
    15151528                fMSF   = (pVScsiReq->pbCDB[1] >> 1) & 1;
    15161529
     1530                vscsiReqSetXferDir(pVScsiReq, VSCSIXFERDIR_T2I);
    15171531                vscsiReqSetXferSize(pVScsiReq, cbMax);
    15181532                switch (format)
    … …  
    15371551                size_t cbMax = scsiBE2H_U16(&pVScsiReq->pbCDB[7]);
    15381552
     1553                vscsiReqSetXferDir(pVScsiReq, VSCSIXFERDIR_T2I);
    15391554                vscsiReqSetXferSize(pVScsiReq, cbMax);
    15401555                if (pVScsiReq->pbCDB[1] & 0x1)
    … …  
    15491564                uint8_t aReply[8];
    15501565
     1566                vscsiReqSetXferDir(pVScsiReq, VSCSIXFERDIR_T2I);
    15511567                vscsiReqSetXferSize(pVScsiReq, cbMax);
    15521568                scsiH2BE_U16(&aReply[0], 0);
    … …  
    15661582                size_t cbMax = scsiBE2H_U16(&pVScsiReq->pbCDB[7]);
    15671583
     1584                vscsiReqSetXferDir(pVScsiReq, VSCSIXFERDIR_T2I);
    15681585                vscsiReqSetXferSize(pVScsiReq, cbMax);
    15691586                memset(aReply, '\0', sizeof(aReply));
    … …  
    15881605            {
    15891606                size_t cbMax = scsiBE2H_U16(&pVScsiReq->pbCDB[7]);
     1607
     1608                vscsiReqSetXferDir(pVScsiReq, VSCSIXFERDIR_T2I);
    15901609                vscsiReqSetXferSize(pVScsiReq, cbMax);
    15911610                rcReq = vscsiLunMmcReadTrackInformation(pVScsiLunMmc, pVScsiReq, cbMax);
    … …  
    15951614            {
    15961615                size_t cbMax = scsiBE2H_U16(&pVScsiReq->pbCDB[7]);
     1616
     1617                vscsiReqSetXferDir(pVScsiReq, VSCSIXFERDIR_T2I);
    15971618                vscsiReqSetXferSize(pVScsiReq, cbMax);
    15981619                rcReq = vscsiLunMmcGetConfiguration(pVScsiLunMmc, pVScsiReq, cbMax);
    … …  
    16021623            {
    16031624                size_t cbMax = scsiBE2H_U16(&pVScsiReq->pbCDB[8]);
     1625
     1626                vscsiReqSetXferDir(pVScsiReq, VSCSIXFERDIR_T2I);
    16041627                vscsiReqSetXferSize(pVScsiReq, cbMax);
    16051628                rcReq = vscsiLunMmcReadDvdStructure(pVScsiLunMmc, pVScsiReq, cbMax);
    … …  
    16171640                 __FUNCTION__, uLbaStart, cSectorTransfer));
    16181641
     1642        vscsiReqSetXferDir(pVScsiReq, enmTxDir == VSCSIIOREQTXDIR_WRITE ? VSCSIXFERDIR_I2T : VSCSIXFERDIR_T2I);
    16191643        vscsiReqSetXferSize(pVScsiReq, cSectorTransfer * cbSector);
    16201644        if (RT_UNLIKELY(uLbaStart + cSectorTransfer > pVScsiLunMmc->cSectors))

  • trunk/src/VBox/Devices/Storage/VSCSI/VSCSILunSbc.cpp

    r80541 r80589  
    201201        case SCSI_INQUIRY:
    202202        {
     203            vscsiReqSetXferDir(pVScsiReq, VSCSIXFERDIR_T2I);
    203204            vscsiReqSetXferSize(pVScsiReq, RT_MIN(sizeof(SCSIINQUIRYDATA), scsiBE2H_U16(&pVScsiReq->pbCDB[3])));
    204205
    … …  
    252253            memset(aReply, 0, sizeof(aReply));
    253254
     255            vscsiReqSetXferDir(pVScsiReq, VSCSIXFERDIR_T2I);
    254256            vscsiReqSetXferSize(pVScsiReq, sizeof(aReply));
    255257
    … …  
    274276            bool    fValid = false;
    275277
     278            vscsiReqSetXferDir(pVScsiReq, VSCSIXFERDIR_T2I);
    276279            vscsiReqSetXferSize(pVScsiReq, pVScsiReq->pbCDB[4]);
    277280            memset(aReply, 0, sizeof(aReply));
    … …  
    312315            size_t  cbList = pVScsiReq->pbCDB[4];
    313316
     317            vscsiReqSetXferDir(pVScsiReq, VSCSIXFERDIR_I2T);
    314318            vscsiReqSetXferSize(pVScsiReq, pVScsiReq->pbCDB[4]);
    315319
    … …  
    405409            uint8_t uDataMode = pVScsiReq->pbCDB[1] & 0x1f;
    406410
     411            vscsiReqSetXferDir(pVScsiReq, VSCSIXFERDIR_T2I);
    407412            vscsiReqSetXferSize(pVScsiReq, scsiBE2H_U16(&pVScsiReq->pbCDB[6]));
    408413
    … …  
    437442        case SCSI_START_STOP_UNIT:
    438443        {
     444            vscsiReqSetXferDir(pVScsiReq, VSCSIXFERDIR_NONE);
    439445            vscsiReqSetXferSize(pVScsiReq, 0);
    440446            rcReq = vscsiLunReqSenseOkSet(pVScsiLun, pVScsiReq);
    … …  
    446452            uint8_t uSubPageCode = pVScsiReq->pbCDB[3];
    447453
     454            vscsiReqSetXferDir(pVScsiReq, VSCSIXFERDIR_T2I);
    448455            vscsiReqSetXferSize(pVScsiReq, scsiBE2H_U16(&pVScsiReq->pbCDB[7]));
    449456
    … …  
    486493                    /* Leave the rest 0 */
    487494
     495                    vscsiReqSetXferDir(pVScsiReq, VSCSIXFERDIR_T2I);
    488496                    vscsiReqSetXferSize(pVScsiReq, sizeof(aReply));
    489497                    RTSgBufCopyFromBuf(&pVScsiReq->SgBuf, aReply, sizeof(aReply));
    … …  
    505513
    506514                /* Copy the header. */
     515                vscsiReqSetXferDir(pVScsiReq, VSCSIXFERDIR_I2T);
    507516                vscsiReqSetXferSize(pVScsiReq, cbList);
    508517                cbCopied = RTSgBufCopyToBuf(&pVScsiReq->SgBuf, &abHdr[0], sizeof(abHdr));
    … …  
    570579        if (RT_UNLIKELY(uLbaStart + cSectorTransfer > pVScsiLunSbc->cSectors))
    571580        {
     581            vscsiReqSetXferDir(pVScsiReq, VSCSIXFERDIR_NONE);
    572582            rcReq = vscsiLunReqSenseErrorSet(pVScsiLun, pVScsiReq, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_LOGICAL_BLOCK_OOR, 0x00);
    573583            vscsiDeviceReqComplete(pVScsiLun->pVScsiDevice, pVScsiReq, rcReq, false, VINF_SUCCESS);
    … …  
    576586        {
    577587            /* A 0 transfer length is not an error. */
     588            vscsiReqSetXferDir(pVScsiReq, VSCSIXFERDIR_NONE);
    578589            rcReq = vscsiLunReqSenseOkSet(pVScsiLun, pVScsiReq);
    579590            vscsiDeviceReqComplete(pVScsiLun->pVScsiDevice, pVScsiReq, rcReq, false, VINF_SUCCESS);
    … …  
    587598                rcReq = vscsiLunReqSenseErrorSet(pVScsiLun, pVScsiReq, SCSI_SENSE_DATA_PROTECT, SCSI_ASC_WRITE_PROTECTED, 0x00);
    588599            else
     600            {
     601                vscsiReqSetXferDir(pVScsiReq, enmTxDir == VSCSIIOREQTXDIR_WRITE ? VSCSIXFERDIR_I2T : VSCSIXFERDIR_T2I);
    589602                rc = vscsiIoReqTransferEnqueue(pVScsiLun, pVScsiReq, enmTxDir,
    590603                                               uLbaStart * 512, cSectorTransfer * 512);
     604            }
    591605        }
    592606    }
    … …  
    594608    {
    595609        /* Enqueue flush */
     610        vscsiReqSetXferDir(pVScsiReq, VSCSIXFERDIR_NONE);
    596611        vscsiReqSetXferSize(pVScsiReq, 0);
    597612        rc = vscsiIoReqFlushEnqueue(pVScsiLun, pVScsiReq);

  • trunk/src/VBox/Devices/Storage/VSCSI/VSCSISense.cpp

    r76553 r80589  
    4444
    4545    if (pVScsiReq->pbSense && pVScsiReq->cbSense)
    46         memcpy(pVScsiReq->pbSense, pVScsiSense->abSenseBuf, RT_MIN(sizeof(pVScsiSense->abSenseBuf), pVScsiReq->cbSense));
     46    {
     47        pVScsiReq->cbSenseWritten = RT_MIN(sizeof(pVScsiSense->abSenseBuf), pVScsiReq->cbSense);
     48        memcpy(pVScsiReq->pbSense, pVScsiSense->abSenseBuf, pVScsiReq->cbSenseWritten);
     49    }
    4750
    4851    return SCSI_STATUS_OK;
    … …  
    5962
    6063    if (pVScsiReq->pbSense && pVScsiReq->cbSense)
    61         memcpy(pVScsiReq->pbSense, pVScsiSense->abSenseBuf, RT_MIN(sizeof(pVScsiSense->abSenseBuf), pVScsiReq->cbSense));
     64    {
     65        pVScsiReq->cbSenseWritten = RT_MIN(sizeof(pVScsiSense->abSenseBuf), pVScsiReq->cbSense);
     66        memcpy(pVScsiReq->pbSense, pVScsiSense->abSenseBuf, pVScsiReq->cbSenseWritten);
     67    }
    6268
    6369    return SCSI_STATUS_CHECK_CONDITION;
    … …  
    7581
    7682    if (pVScsiReq->pbSense && pVScsiReq->cbSense)
    77         memcpy(pVScsiReq->pbSense, pVScsiSense->abSenseBuf, RT_MIN(sizeof(pVScsiSense->abSenseBuf), pVScsiReq->cbSense));
     83    {
     84        pVScsiReq->cbSenseWritten = RT_MIN(sizeof(pVScsiSense->abSenseBuf), pVScsiReq->cbSense);
     85        memcpy(pVScsiReq->pbSense, pVScsiSense->abSenseBuf, pVScsiReq->cbSenseWritten);
     86    }
    7887
    7988    return SCSI_STATUS_CHECK_CONDITION;
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