DrvSCSI.cpp revision 9dca051a5f8ff457ef1692990f6ecfa280daf265
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync/* $Id$ */
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync/** @file
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync *
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync * VBox storage drivers:
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync * Generic SCSI command parser and execution driver
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync */
e64031e20c39650a7bc902a3e1aba613b9415deevboxsync
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync/*
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync * Copyright (C) 2006-2009 Sun Microsystems, Inc.
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync *
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync * This file is part of VirtualBox Open Source Edition (OSE), as
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync * available from http://www.virtualbox.org. This file is free software;
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync * you can redistribute it and/or modify it under the terms of the GNU
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync * General Public License (GPL) as published by the Free Software
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync * Foundation, in version 2 as it comes in the "COPYING" file of the
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync *
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync * Clara, CA 95054 USA or visit http://www.sun.com if you need
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync * additional information or have any questions.
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync */
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync/*******************************************************************************
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync* Header Files *
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync*******************************************************************************/
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync//#define DEBUG
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync#define LOG_GROUP LOG_GROUP_DRV_SCSI
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync#include <VBox/pdmdrv.h>
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync#include <VBox/pdmifs.h>
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync#include <VBox/pdmthread.h>
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync#include <VBox/scsi.h>
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync#include <iprt/assert.h>
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync#include <iprt/string.h>
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync#include <iprt/alloc.h>
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync#include <iprt/req.h>
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync#include <iprt/semaphore.h>
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync
39c2eccedfdb7455c52225543c355e33a65f0c81vboxsync#include "Builtins.h"
39c2eccedfdb7455c52225543c355e33a65f0c81vboxsync
39c2eccedfdb7455c52225543c355e33a65f0c81vboxsync/**
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync * SCSI driver instance data.
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync */
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsynctypedef struct DRVSCSI
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync{
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync /** Pointer driver instance. */
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync PPDMDRVINS pDrvIns;
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync
0612e2adbcc146b9eb7748983c720e35e38d0dc9vboxsync /** Pointer to the attached driver's base interface. */
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync PPDMIBASE pDrvBase;
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync /** Pointer to the attached driver's block interface. */
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync PPDMIBLOCK pDrvBlock;
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync /** Pointer to the attached driver's async block interface. */
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync PPDMIBLOCKASYNC pDrvBlockAsync;
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync /** Pointer to the attached driver's block bios interface. */
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync PPDMIBLOCKBIOS pDrvBlockBios;
0612e2adbcc146b9eb7748983c720e35e38d0dc9vboxsync /** Pointer to the attached driver's mount interface. */
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync PPDMIMOUNT pDrvMount;
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync /** Pointer to the SCSI port interface of the device above. */
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync PPDMISCSIPORT pDevScsiPort;
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync /** pointer to the Led port interface of the dveice above. */
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync PPDMILEDPORTS pLedPort;
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync /** The scsi connector interface .*/
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync PDMISCSICONNECTOR ISCSIConnector;
0612e2adbcc146b9eb7748983c720e35e38d0dc9vboxsync /** The block port interface. */
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync PDMIBLOCKPORT IPort;
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync /** The optional block async port interface. */
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync PDMIBLOCKASYNCPORT IPortAsync;
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync /** The mount notify interface. */
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync PDMIMOUNTNOTIFY IMountNotify;
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync /** The status LED state for this drive.
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync * used in case the device doesn't has a Led interface
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync * so we can use this to avoid if checks later on. */
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync PDMLED Led;
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync /** pointer to the Led to use. */
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync PPDMLED pLed;
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync /** Device type. */
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync PDMBLOCKTYPE enmType;
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync /** BIOS PCHS Geometry. */
39c2eccedfdb7455c52225543c355e33a65f0c81vboxsync PDMMEDIAGEOMETRY PCHSGeometry;
39c2eccedfdb7455c52225543c355e33a65f0c81vboxsync /** BIOS LCHS Geometry. */
39c2eccedfdb7455c52225543c355e33a65f0c81vboxsync PDMMEDIAGEOMETRY LCHSGeometry;
39c2eccedfdb7455c52225543c355e33a65f0c81vboxsync /** Number of sectors this device has. */
39c2eccedfdb7455c52225543c355e33a65f0c81vboxsync uint64_t cSectors;
39c2eccedfdb7455c52225543c355e33a65f0c81vboxsync
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync /** The dedicated I/O thread for the non async approach. */
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync PPDMTHREAD pAsyncIOThread;
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync /** Queue for passing the requests to the thread. */
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync PRTREQQUEUE pQueueRequests;
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync /** Release statistics: number of bytes written. */
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync STAMCOUNTER StatBytesWritten;
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync /** Release statistics: number of bytes read. */
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync STAMCOUNTER StatBytesRead;
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync} DRVSCSI, *PDRVSCSI;
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync/** Converts a pointer to DRVSCSI::ISCSIConnecotr to a PDRVSCSI. */
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync#define PDMISCSICONNECTOR_2_DRVSCSI(pInterface) ( (PDRVSCSI)((uintptr_t)pInterface - RT_OFFSETOF(DRVSCSI, ISCSIConnector)) )
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync#ifdef DEBUG
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync/**
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync * Dumps a SCSI request structure for debugging purposes.
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync *
0368e9c310393e82ef37c480b6acbd0f107cf0edvboxsync * @returns nothing.
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync * @param pRequest Pointer to the request to dump.
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync */
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsyncstatic void drvscsiDumpScsiRequest(PPDMSCSIREQUEST pRequest)
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync{
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync Log(("Dump for pRequest=%#p Command: %s\n", pRequest, SCSICmdText(pRequest->pbCDB[0])));
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync Log(("cbCDB=%u\n", pRequest->cbCDB));
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync for (uint32_t i = 0; i < pRequest->cbCDB; i++)
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync Log(("pbCDB[%u]=%#x\n", i, pRequest->pbCDB[i]));
d1c36fd86d36726777e3d6f9d040573e0aaf30devboxsync Log(("cbScatterGather=%u\n", pRequest->cbScatterGather));
d1c36fd86d36726777e3d6f9d040573e0aaf30devboxsync Log(("cScatterGatherEntries=%u\n", pRequest->cScatterGatherEntries));
d1c36fd86d36726777e3d6f9d040573e0aaf30devboxsync /* Print all scatter gather entries. */
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync for (uint32_t i = 0; i < pRequest->cScatterGatherEntries; i++)
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync {
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync Log(("ScatterGatherEntry[%u].cbSeg=%u\n", i, pRequest->paScatterGatherHead[i].cbSeg));
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync Log(("ScatterGatherEntry[%u].pvSeg=%#p\n", i, pRequest->paScatterGatherHead[i].pvSeg));
d1c36fd86d36726777e3d6f9d040573e0aaf30devboxsync }
d1c36fd86d36726777e3d6f9d040573e0aaf30devboxsync Log(("pvUser=%#p\n", pRequest->pvUser));
d1c36fd86d36726777e3d6f9d040573e0aaf30devboxsync}
d1c36fd86d36726777e3d6f9d040573e0aaf30devboxsync#endif
d1c36fd86d36726777e3d6f9d040573e0aaf30devboxsync
d1c36fd86d36726777e3d6f9d040573e0aaf30devboxsync/**
d1c36fd86d36726777e3d6f9d040573e0aaf30devboxsync * Copy the content of a buffer to a scatter gather list only
d1c36fd86d36726777e3d6f9d040573e0aaf30devboxsync * copying only the amount of data which fits into the
d1c36fd86d36726777e3d6f9d040573e0aaf30devboxsync * scatter gather list.
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync *
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync * @returns VBox status code.
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync * @param pRequest Pointer to the request which contains the S/G list entries.
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync * @param pvBuf Pointer to the buffer which should be copied.
d1c36fd86d36726777e3d6f9d040573e0aaf30devboxsync * @param cbBuf Size of the buffer.
d1c36fd86d36726777e3d6f9d040573e0aaf30devboxsync */
d1c36fd86d36726777e3d6f9d040573e0aaf30devboxsyncstatic int drvscsiScatterGatherListCopyFromBuffer(PPDMSCSIREQUEST pRequest, void *pvBuf, size_t cbBuf)
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync{
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync unsigned cSGEntry = 0;
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync PPDMDATASEG pSGEntry = &pRequest->paScatterGatherHead[cSGEntry];
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync uint8_t *pu8Buf = (uint8_t *)pvBuf;
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync LogFlowFunc(("pRequest=%#p pvBuf=%#p cbBuf=%u\n", pRequest, pvBuf, cbBuf));
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync#ifdef DEBUG
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync for (unsigned i = 0; i < cbBuf; i++)
d1c36fd86d36726777e3d6f9d040573e0aaf30devboxsync Log(("%s: pvBuf[%u]=%#x\n", __FUNCTION__, i, pu8Buf[i]));
d1c36fd86d36726777e3d6f9d040573e0aaf30devboxsync#endif
d1c36fd86d36726777e3d6f9d040573e0aaf30devboxsync
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync while (cSGEntry < pRequest->cScatterGatherEntries)
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync {
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync size_t cbToCopy = (cbBuf < pSGEntry->cbSeg) ? cbBuf : pSGEntry->cbSeg;
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync memcpy(pSGEntry->pvSeg, pu8Buf, cbToCopy);
d1c36fd86d36726777e3d6f9d040573e0aaf30devboxsync
d1c36fd86d36726777e3d6f9d040573e0aaf30devboxsync cbBuf -= cbToCopy;
d1c36fd86d36726777e3d6f9d040573e0aaf30devboxsync /* We finished. */
d1c36fd86d36726777e3d6f9d040573e0aaf30devboxsync if (!cbBuf)
d1c36fd86d36726777e3d6f9d040573e0aaf30devboxsync break;
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync /* Advance the buffer. */
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync pu8Buf += cbToCopy;
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync /* Go to the next entry in the list. */
d1c36fd86d36726777e3d6f9d040573e0aaf30devboxsync pSGEntry++;
d1c36fd86d36726777e3d6f9d040573e0aaf30devboxsync cSGEntry++;
d1c36fd86d36726777e3d6f9d040573e0aaf30devboxsync }
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync return VINF_SUCCESS;
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync}
d1c36fd86d36726777e3d6f9d040573e0aaf30devboxsync
d1c36fd86d36726777e3d6f9d040573e0aaf30devboxsyncstatic void drvscsiPadStr(int8_t *pbDst, const char *pbSrc, uint32_t cbSize)
d1c36fd86d36726777e3d6f9d040573e0aaf30devboxsync{
d1c36fd86d36726777e3d6f9d040573e0aaf30devboxsync for (uint32_t i = 0; i < cbSize; i++)
d1c36fd86d36726777e3d6f9d040573e0aaf30devboxsync {
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync if (*pbSrc)
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync pbDst[i] = *pbSrc++;
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync else
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync pbDst[i] = ' ';
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync }
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync}
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync
0612e2adbcc146b9eb7748983c720e35e38d0dc9vboxsync/**
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync * Set the sense and advanced sense key in the buffer for error conditions.
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync *
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync * @returns SCSI status code.
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync * @param pRequest Pointer to the request which contains the sense buffer.
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync * @param uSCSISenseKey The sense key to set.
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync * @param uSCSIASC The advanced sense key to set.
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync */
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsyncDECLINLINE(int) drvscsiCmdError(PPDMSCSIREQUEST pRequest, uint8_t uSCSISenseKey, uint8_t uSCSIASC)
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync{
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync AssertMsgReturn(pRequest->cbSenseBuffer >= 18, ("Sense buffer is not big enough\n"), SCSI_STATUS_OK);
0612e2adbcc146b9eb7748983c720e35e38d0dc9vboxsync AssertMsgReturn(pRequest->pbSenseBuffer, ("Sense buffer pointer is NULL\n"), SCSI_STATUS_OK);
0612e2adbcc146b9eb7748983c720e35e38d0dc9vboxsync memset(pRequest->pbSenseBuffer, 0, pRequest->cbSenseBuffer);
0612e2adbcc146b9eb7748983c720e35e38d0dc9vboxsync pRequest->pbSenseBuffer[0] = (1 << 7) | SCSI_SENSE_RESPONSE_CODE_CURR_FIXED; /* Fixed format */
0612e2adbcc146b9eb7748983c720e35e38d0dc9vboxsync pRequest->pbSenseBuffer[2] = uSCSISenseKey;
0612e2adbcc146b9eb7748983c720e35e38d0dc9vboxsync pRequest->pbSenseBuffer[7] = 10;
0612e2adbcc146b9eb7748983c720e35e38d0dc9vboxsync pRequest->pbSenseBuffer[12] = uSCSIASC;
0612e2adbcc146b9eb7748983c720e35e38d0dc9vboxsync pRequest->pbSenseBuffer[13] = 0x00; /** @todo: Provide more info. */
0612e2adbcc146b9eb7748983c720e35e38d0dc9vboxsync return SCSI_STATUS_CHECK_CONDITION;
0612e2adbcc146b9eb7748983c720e35e38d0dc9vboxsync}
0612e2adbcc146b9eb7748983c720e35e38d0dc9vboxsync
0612e2adbcc146b9eb7748983c720e35e38d0dc9vboxsync/**
0612e2adbcc146b9eb7748983c720e35e38d0dc9vboxsync * Sets the sense key for a status good condition.
0612e2adbcc146b9eb7748983c720e35e38d0dc9vboxsync *
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync * @returns SCSI status code.
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync * @param pRequest Pointer to the request which contains the sense buffer.
0612e2adbcc146b9eb7748983c720e35e38d0dc9vboxsync */
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsyncDECLINLINE(int) drvscsiCmdOk(PPDMSCSIREQUEST pRequest)
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync{
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync AssertMsgReturn(pRequest->cbSenseBuffer >= 18, ("Sense buffer is not big enough\n"), SCSI_STATUS_OK);
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync AssertMsgReturn(pRequest->pbSenseBuffer, ("Sense buffer pointer is NULL\n"), SCSI_STATUS_OK);
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync memset(pRequest->pbSenseBuffer, 0, pRequest->cbSenseBuffer);
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync /*
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync * Setting this breaks Linux guests on the BusLogic controller.
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync * According to the SCSI SPC spec sense data is returned after a
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync * CHECK CONDITION status or a REQUEST SENSE command.
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync * Both SCSI controllers have a feature called Auto Sense which
0612e2adbcc146b9eb7748983c720e35e38d0dc9vboxsync * fetches the sense data automatically from the device
0612e2adbcc146b9eb7748983c720e35e38d0dc9vboxsync * with REQUEST SENSE. So the SCSI subsystem in Linux should
0612e2adbcc146b9eb7748983c720e35e38d0dc9vboxsync * find this sense data even if the command finishes successfully
0612e2adbcc146b9eb7748983c720e35e38d0dc9vboxsync * but if it finds valid sense data it will let the command fail
0612e2adbcc146b9eb7748983c720e35e38d0dc9vboxsync * and it doesn't detect attached disks anymore.
0612e2adbcc146b9eb7748983c720e35e38d0dc9vboxsync * Disabling makes it work again and no other guest shows errors
0612e2adbcc146b9eb7748983c720e35e38d0dc9vboxsync * so I will leave it disabled for now.
0612e2adbcc146b9eb7748983c720e35e38d0dc9vboxsync *
0612e2adbcc146b9eb7748983c720e35e38d0dc9vboxsync * On the other hand it is possible that the devices fetch the sense data
0612e2adbcc146b9eb7748983c720e35e38d0dc9vboxsync * only after a command failed so the content is really invalid if
0612e2adbcc146b9eb7748983c720e35e38d0dc9vboxsync * the command succeeds.
39c2eccedfdb7455c52225543c355e33a65f0c81vboxsync */
39c2eccedfdb7455c52225543c355e33a65f0c81vboxsync#if 0
39c2eccedfdb7455c52225543c355e33a65f0c81vboxsync pRequest->pbSenseBuffer[0] = (1 << 7) | SCSI_SENSE_RESPONSE_CODE_CURR_FIXED; /* Fixed format */
39c2eccedfdb7455c52225543c355e33a65f0c81vboxsync pRequest->pbSenseBuffer[2] = SCSI_SENSE_NONE;
39c2eccedfdb7455c52225543c355e33a65f0c81vboxsync pRequest->pbSenseBuffer[7] = 10;
39c2eccedfdb7455c52225543c355e33a65f0c81vboxsync pRequest->pbSenseBuffer[12] = SCSI_ASC_NONE;
d8dee9a7ef33d4c705d5fd087d5af9c7cb071f85vboxsync pRequest->pbSenseBuffer[13] = SCSI_ASC_NONE; /* Should be ASCQ but it has the same value for success. */
39c2eccedfdb7455c52225543c355e33a65f0c81vboxsync#endif
39c2eccedfdb7455c52225543c355e33a65f0c81vboxsync return SCSI_STATUS_OK;
39c2eccedfdb7455c52225543c355e33a65f0c81vboxsync}
39c2eccedfdb7455c52225543c355e33a65f0c81vboxsync
39c2eccedfdb7455c52225543c355e33a65f0c81vboxsyncDECLINLINE(void) drvscsiH2BE_U16(uint8_t *pbBuf, uint16_t val)
39c2eccedfdb7455c52225543c355e33a65f0c81vboxsync{
d8dee9a7ef33d4c705d5fd087d5af9c7cb071f85vboxsync pbBuf[0] = val >> 8;
39c2eccedfdb7455c52225543c355e33a65f0c81vboxsync pbBuf[1] = val;
39c2eccedfdb7455c52225543c355e33a65f0c81vboxsync}
39c2eccedfdb7455c52225543c355e33a65f0c81vboxsync
39c2eccedfdb7455c52225543c355e33a65f0c81vboxsync
39c2eccedfdb7455c52225543c355e33a65f0c81vboxsyncDECLINLINE(void) drvscsiH2BE_U24(uint8_t *pbBuf, uint32_t val)
39c2eccedfdb7455c52225543c355e33a65f0c81vboxsync{
d8dee9a7ef33d4c705d5fd087d5af9c7cb071f85vboxsync pbBuf[0] = val >> 16;
39c2eccedfdb7455c52225543c355e33a65f0c81vboxsync pbBuf[1] = val >> 8;
39c2eccedfdb7455c52225543c355e33a65f0c81vboxsync pbBuf[2] = val;
39c2eccedfdb7455c52225543c355e33a65f0c81vboxsync}
39c2eccedfdb7455c52225543c355e33a65f0c81vboxsync
d8dee9a7ef33d4c705d5fd087d5af9c7cb071f85vboxsync
d8dee9a7ef33d4c705d5fd087d5af9c7cb071f85vboxsyncDECLINLINE(void) drvscsiH2BE_U32(uint8_t *pbBuf, uint32_t val)
d8dee9a7ef33d4c705d5fd087d5af9c7cb071f85vboxsync{
d8dee9a7ef33d4c705d5fd087d5af9c7cb071f85vboxsync pbBuf[0] = val >> 24;
d8dee9a7ef33d4c705d5fd087d5af9c7cb071f85vboxsync pbBuf[1] = val >> 16;
d8dee9a7ef33d4c705d5fd087d5af9c7cb071f85vboxsync pbBuf[2] = val >> 8;
b35e3948f1287430503b6b432945b8cf4bfd3a23vboxsync pbBuf[3] = val;
d8dee9a7ef33d4c705d5fd087d5af9c7cb071f85vboxsync}
d8dee9a7ef33d4c705d5fd087d5af9c7cb071f85vboxsync
d8dee9a7ef33d4c705d5fd087d5af9c7cb071f85vboxsync
d8dee9a7ef33d4c705d5fd087d5af9c7cb071f85vboxsyncDECLINLINE(uint16_t) drvscsiBE2H_U16(const uint8_t *pbBuf)
d8dee9a7ef33d4c705d5fd087d5af9c7cb071f85vboxsync{
d8dee9a7ef33d4c705d5fd087d5af9c7cb071f85vboxsync return (pbBuf[0] << 8) | pbBuf[1];
d8dee9a7ef33d4c705d5fd087d5af9c7cb071f85vboxsync}
d8dee9a7ef33d4c705d5fd087d5af9c7cb071f85vboxsync
d8dee9a7ef33d4c705d5fd087d5af9c7cb071f85vboxsync
d8dee9a7ef33d4c705d5fd087d5af9c7cb071f85vboxsyncDECLINLINE(uint32_t) drvscsiBE2H_U24(const uint8_t *pbBuf)
d8dee9a7ef33d4c705d5fd087d5af9c7cb071f85vboxsync{
d8dee9a7ef33d4c705d5fd087d5af9c7cb071f85vboxsync return (pbBuf[0] << 16) | (pbBuf[1] << 8) | pbBuf[2];
d8dee9a7ef33d4c705d5fd087d5af9c7cb071f85vboxsync}
d8dee9a7ef33d4c705d5fd087d5af9c7cb071f85vboxsync
d8dee9a7ef33d4c705d5fd087d5af9c7cb071f85vboxsync
d8dee9a7ef33d4c705d5fd087d5af9c7cb071f85vboxsyncDECLINLINE(uint32_t) drvscsiBE2H_U32(const uint8_t *pbBuf)
d8dee9a7ef33d4c705d5fd087d5af9c7cb071f85vboxsync{
d8dee9a7ef33d4c705d5fd087d5af9c7cb071f85vboxsync return (pbBuf[0] << 24) | (pbBuf[1] << 16) | (pbBuf[2] << 8) | pbBuf[3];
d8dee9a7ef33d4c705d5fd087d5af9c7cb071f85vboxsync}
d8dee9a7ef33d4c705d5fd087d5af9c7cb071f85vboxsync
0612e2adbcc146b9eb7748983c720e35e38d0dc9vboxsyncDECLINLINE(uint64_t) drvscsiBE2H_U64(const uint8_t *pbBuf)
e2a73964f463b9e91f6f096f9e15974a3edcc416vboxsync{
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync return ((uint64_t)pbBuf[0] << 56)
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync | ((uint64_t)pbBuf[1] << 48)
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync | ((uint64_t)pbBuf[2] << 40)
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync | ((uint64_t)pbBuf[3] << 32)
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync | ((uint64_t)pbBuf[4] << 24)
84f746c9015f34e9ab096b87e063d0d6ab7fc7aevboxsync | ((uint64_t)pbBuf[5] << 16)
| ((uint64_t)pbBuf[6] << 8)
| (uint64_t)pbBuf[7];
}
/**
* Parses the CDB of a request and acts accordingly.
*
* @returns transfer direction type.
* @param pThis Pointer to the SCSI driver instance data.
* @param pRequest Pointer to the request to process.
* @param puOffset Where to store the start offset to start data transfer from.
* @param pcbToTransfer Where to store the number of bytes to transfer.
* @param piTxDir Where to store the data transfer direction.
*/
static int drvscsiProcessCDB(PDRVSCSI pThis, PPDMSCSIREQUEST pRequest, uint64_t *puOffset, uint32_t *pcbToTransfer, int *piTxDir)
{
int iTxDir = PDMBLOCKTXDIR_NONE;
int rc = SCSI_STATUS_OK;
/* We check for a command which needs to be handled even for non existant LUNs. */
switch (pRequest->pbCDB[0])
{
case SCSI_INQUIRY:
{
SCSIINQUIRYDATA ScsiInquiryReply;
memset(&ScsiInquiryReply, 0, sizeof(ScsiInquiryReply));
ScsiInquiryReply.cbAdditional = 31;
/* We support only one attached device at LUN0 at the moment. */
if (pRequest->uLogicalUnit != 0)
{
ScsiInquiryReply.u5PeripheralDeviceType = SCSI_INQUIRY_DATA_PERIPHERAL_DEVICE_TYPE_UNKNOWN;
ScsiInquiryReply.u3PeripheralQualifier = SCSI_INQUIRY_DATA_PERIPHERAL_QUALIFIER_NOT_CONNECTED_NOT_SUPPORTED;
}
else
{
switch (pThis->enmType)
{
case PDMBLOCKTYPE_HARD_DISK:
ScsiInquiryReply.u5PeripheralDeviceType = SCSI_INQUIRY_DATA_PERIPHERAL_DEVICE_TYPE_DIRECT_ACCESS;
break;
default:
AssertMsgFailed(("Device type %u not supported\n", pThis->enmType));
}
ScsiInquiryReply.u3PeripheralQualifier = SCSI_INQUIRY_DATA_PERIPHERAL_QUALIFIER_CONNECTED;
ScsiInquiryReply.u3AnsiVersion = 0x05; /* SPC-4 compliant */
drvscsiPadStr(ScsiInquiryReply.achVendorId, "VBOX", 8);
drvscsiPadStr(ScsiInquiryReply.achProductId, "HARDDISK", 16);
drvscsiPadStr(ScsiInquiryReply.achProductLevel, "1.0", 4);
}
drvscsiScatterGatherListCopyFromBuffer(pRequest, &ScsiInquiryReply, sizeof(SCSIINQUIRYDATA));
rc = drvscsiCmdOk(pRequest);
break;
}
case SCSI_REPORT_LUNS:
{
/*
* If allocation length is less than 16 bytes SPC compliant devices have
* to return an error.
*/
if (drvscsiBE2H_U32(&pRequest->pbCDB[6]) < 16)
rc = drvscsiCmdError(pRequest, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_INV_FIELD_IN_CMD_PACKET);
else
{
uint8_t aReply[16]; /* We report only one LUN. */
memset(aReply, 0, sizeof(aReply));
drvscsiH2BE_U32(&aReply[0], 8); /* List length starts at position 0. */
drvscsiScatterGatherListCopyFromBuffer(pRequest, aReply, sizeof(aReply));
rc = drvscsiCmdOk(pRequest);
}
break;
}
case SCSI_TEST_UNIT_READY:
{
rc = drvscsiCmdOk(pRequest);
break;
}
default:
{
/* Now for commands which are only implemented for existant LUNs. */
if (RT_LIKELY(pRequest->uLogicalUnit == 0))
{
switch(pRequest->pbCDB[0])
{
case SCSI_READ_CAPACITY:
{
uint8_t aReply[8];
memset(aReply, 0, sizeof(aReply));
/*
* If sector size exceeds the maximum value that is
* able to be stored in 4 bytes return 0xffffffff in this field
*/
if (pThis->cSectors > UINT32_C(0xffffffff))
drvscsiH2BE_U32(aReply, UINT32_C(0xffffffff));
else
drvscsiH2BE_U32(aReply, pThis->cSectors - 1);
drvscsiH2BE_U32(&aReply[4], 512);
drvscsiScatterGatherListCopyFromBuffer(pRequest, aReply, sizeof(aReply));
rc = drvscsiCmdOk(pRequest);
break;
}
case SCSI_SERVICE_ACTION_IN_16:
{
AssertMsgFailed(("Not implemented yet.\n"));
break;
}
case SCSI_MODE_SENSE_6:
{
uint8_t uModePage = pRequest->pbCDB[2] & 0x3f;
uint8_t aReply[24];
uint8_t *pu8ReplyPos;
memset(aReply, 0, sizeof(aReply));
aReply[0] = 4; /* Reply length 4. */
aReply[1] = 0; /* Default media type. */
aReply[2] = RT_BIT(4); /* Caching supported. */
aReply[3] = 0; /* Block descriptor length. */
pu8ReplyPos = aReply + 4;
if ((uModePage == 0x08) || (uModePage == 0x3f))
{
memset(pu8ReplyPos, 0, 20);
*pu8ReplyPos++ = 0x08; /* Page code. */
*pu8ReplyPos++ = 0x12; /* Size of the page. */
*pu8ReplyPos++ = 0x4; /* Write cache enabled. */
}
drvscsiScatterGatherListCopyFromBuffer(pRequest, aReply, sizeof(aReply));
rc = drvscsiCmdOk(pRequest);
break;
}
case SCSI_READ_6:
{
iTxDir = PDMBLOCKTXDIR_FROM_DEVICE;
*puOffset = ((uint64_t) pRequest->pbCDB[3]
| (pRequest->pbCDB[2] << 8)
| ((pRequest->pbCDB[1] & 0x1f) << 16)) * 512;
*pcbToTransfer = ((uint32_t)pRequest->pbCDB[4]) * 512;
break;
}
case SCSI_READ_10:
{
iTxDir = PDMBLOCKTXDIR_FROM_DEVICE;
*puOffset = ((uint64_t)drvscsiBE2H_U32(&pRequest->pbCDB[2])) * 512;
*pcbToTransfer = ((uint32_t)drvscsiBE2H_U16(&pRequest->pbCDB[7])) * 512;
break;
}
case SCSI_READ_12:
{
iTxDir = PDMBLOCKTXDIR_FROM_DEVICE;
*puOffset = ((uint64_t)drvscsiBE2H_U32(&pRequest->pbCDB[2])) * 512;
*pcbToTransfer = ((uint32_t)drvscsiBE2H_U32(&pRequest->pbCDB[6])) * 512;
break;
}
case SCSI_READ_16:
{
iTxDir = PDMBLOCKTXDIR_FROM_DEVICE;
*puOffset = drvscsiBE2H_U64(&pRequest->pbCDB[2]) * 512;
*pcbToTransfer = ((uint32_t)drvscsiBE2H_U32(&pRequest->pbCDB[6])) * 512;
break;
}
case SCSI_WRITE_6:
{
iTxDir = PDMBLOCKTXDIR_TO_DEVICE;
*puOffset = ((uint64_t) pRequest->pbCDB[3]
| (pRequest->pbCDB[2] << 8)
| ((pRequest->pbCDB[1] & 0x1f) << 16)) * 512;
*pcbToTransfer = ((uint32_t)pRequest->pbCDB[4]) * 512;
break;
}
case SCSI_WRITE_10:
{
iTxDir = PDMBLOCKTXDIR_TO_DEVICE;
*puOffset = ((uint64_t)drvscsiBE2H_U32(&pRequest->pbCDB[2])) * 512;
*pcbToTransfer = ((uint32_t)drvscsiBE2H_U16(&pRequest->pbCDB[7])) * 512;
break;
}
case SCSI_WRITE_12:
{
iTxDir = PDMBLOCKTXDIR_TO_DEVICE;
*puOffset = ((uint64_t)drvscsiBE2H_U32(&pRequest->pbCDB[2])) * 512;
*pcbToTransfer = ((uint32_t)drvscsiBE2H_U32(&pRequest->pbCDB[6])) * 512;
break;
}
case SCSI_WRITE_16:
{
iTxDir = PDMBLOCKTXDIR_TO_DEVICE;
*puOffset = drvscsiBE2H_U64(&pRequest->pbCDB[2]) * 512;
*pcbToTransfer = ((uint32_t)drvscsiBE2H_U32(&pRequest->pbCDB[6])) * 512;
break;
}
case SCSI_SYNCHRONIZE_CACHE:
{
/* @todo When async mode implemented we have to move this out here. */
int rc2 = pThis->pDrvBlock->pfnFlush(pThis->pDrvBlock);
AssertMsgRC(rc2, ("Flushing data failed rc=%Rrc\n", rc2));
break;
}
case SCSI_READ_BUFFER:
{
uint8_t uDataMode = pRequest->pbCDB[1] & 0x1f;
switch (uDataMode)
{
case 0x00:
case 0x01:
case 0x02:
case 0x03:
case 0x0a:
break;
case 0x0b:
{
uint8_t aReply[4];
/* We do not implement an echo buffer. */
memset(aReply, 0, sizeof(aReply));
drvscsiScatterGatherListCopyFromBuffer(pRequest, aReply, sizeof(aReply));
rc = drvscsiCmdOk(pRequest);
break;
}
case 0x1a:
case 0x1c:
break;
default:
AssertMsgFailed(("Invalid data mode\n"));
}
break;
}
case SCSI_START_STOP_UNIT:
{
/* Nothing to do. */
break;
}
case SCSI_LOG_SENSE:
{
uint16_t cbMax = drvscsiBE2H_U16(&pRequest->pbCDB[7]);
uint8_t uPageCode = pRequest->pbCDB[2] & 0x3f;
uint8_t uSubPageCode = pRequest->pbCDB[3];
switch (uPageCode)
{
case 0x00:
{
if (uSubPageCode == 0)
{
uint8_t aReply[4];
aReply[0] = 0;
aReply[1] = 0;
aReply[2] = 0;
aReply[3] = 0;
drvscsiScatterGatherListCopyFromBuffer(pRequest, aReply, sizeof(aReply));
rc = drvscsiCmdOk(pRequest);
break;
}
}
default:
rc = drvscsiCmdError(pRequest, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_INV_FIELD_IN_CMD_PACKET);
}
break;
}
default:
//AssertMsgFailed(("Command %#x [%s] not implemented\n", pRequest->pbCDB[0], SCSICmdText(pRequest->pbCDB[0])));
rc = drvscsiCmdError(pRequest, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_ILLEGAL_OPCODE);
}
}
else
{
/* Report an error. */
rc = drvscsiCmdError(pRequest, SCSI_SENSE_ILLEGAL_REQUEST, SCSI_ASC_LOGICAL_UNIT_DOES_NOT_RESPOND_TO_SELECTION);
}
break;
}
}
*piTxDir = iTxDir;
return rc;
}
static int drvscsiProcessRequestOne(PDRVSCSI pThis, PPDMSCSIREQUEST pRequest)
{
int rc = VINF_SUCCESS;
int iTxDir;
int rcCompletion;
uint64_t uOffset;
uint32_t cbToTransfer;
uint32_t cSegmentsLeft;
LogFlowFunc(("Entered\n"));
#ifdef DEBUG
drvscsiDumpScsiRequest(pRequest);
#endif
rcCompletion = drvscsiProcessCDB(pThis, pRequest, &uOffset, &cbToTransfer, &iTxDir);
if ((rcCompletion == SCSI_STATUS_OK) && (iTxDir != PDMBLOCKTXDIR_NONE))
{
PPDMDATASEG pSegActual;
pSegActual = &pRequest->paScatterGatherHead[0];
cSegmentsLeft = pRequest->cScatterGatherEntries;
while(cbToTransfer && cSegmentsLeft)
{
uint32_t cbProcess = (cbToTransfer < pSegActual->cbSeg) ? cbToTransfer : (uint32_t)pSegActual->cbSeg;
Log(("%s: uOffset=%llu cbToTransfer=%u\n", __FUNCTION__, uOffset, cbToTransfer));
if (iTxDir == PDMBLOCKTXDIR_FROM_DEVICE)
{
pThis->pLed->Asserted.s.fReading = pThis->pLed->Actual.s.fReading = 1;
rc = pThis->pDrvBlock->pfnRead(pThis->pDrvBlock, uOffset,
pSegActual->pvSeg, cbProcess);
pThis->pLed->Actual.s.fReading = 0;
if (RT_FAILURE(rc))
AssertMsgFailed(("%s: Failed to read data %Rrc\n", __FUNCTION__, rc));
STAM_REL_COUNTER_ADD(&pThis->StatBytesRead, cbProcess);
}
else
{
pThis->pLed->Asserted.s.fWriting = pThis->pLed->Actual.s.fWriting = 1;
rc = pThis->pDrvBlock->pfnWrite(pThis->pDrvBlock, uOffset,
pSegActual->pvSeg, cbProcess);
pThis->pLed->Actual.s.fWriting = 0;
if (RT_FAILURE(rc))
AssertMsgFailed(("%s: Failed to write data %Rrc\n", __FUNCTION__, rc));
STAM_REL_COUNTER_ADD(&pThis->StatBytesWritten, cbProcess);
}
/* Go to the next entry. */
uOffset += cbProcess;
cbToTransfer -= cbProcess;
pSegActual++;
cSegmentsLeft--;
}
AssertMsg(!cbToTransfer && !cSegmentsLeft,
("Transfer incomplete cbToTransfer=%u cSegmentsLeft=%u", cbToTransfer, cSegmentsLeft));
drvscsiCmdOk(pRequest);
}
/* Notify device. */
rc = pThis->pDevScsiPort->pfnSCSIRequestCompleted(pThis->pDevScsiPort, pRequest, rcCompletion);
AssertMsgRC(rc, ("Error while notifying device rc=%Rrc\n", rc));
return rc;
}
/**
* Request function to wakeup the thread.
*
* @returns VWRN_STATE_CHANGED.
*/
static int drvscsiAsyncIOLoopWakeupFunc(void)
{
return VWRN_STATE_CHANGED;
}
/**
* The thread function which processes the requests asynchronously.
*
* @returns VBox status code.
* @param pDrvIns Pointer to the device instance data.
* @param pThread Pointer to the thread instance data.
*/
static int drvscsiAsyncIOLoop(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
{
int rc = VINF_SUCCESS;
PDRVSCSI pThis = PDMINS_2_DATA(pDrvIns, PDRVSCSI);
LogFlowFunc(("Entering async IO loop.\n"));
if (pThread->enmState == PDMTHREADSTATE_INITIALIZING)
return VINF_SUCCESS;
while (pThread->enmState == PDMTHREADSTATE_RUNNING)
{
rc = RTReqProcess(pThis->pQueueRequests, RT_INDEFINITE_WAIT);
AssertMsg(rc == VWRN_STATE_CHANGED, ("Left RTReqProcess and error code is not VWRN_STATE_CHANGED rc=%Rrc\n", rc));
}
return VINF_SUCCESS;
}
static int drvscsiAsyncIOLoopWakeup(PPDMDRVINS pDrvIns, PPDMTHREAD pThread)
{
int rc;
PDRVSCSI pThis = PDMINS_2_DATA(pDrvIns, PDRVSCSI);
PRTREQ pReq;
AssertMsgReturn(pThis->pQueueRequests, ("pQueueRequests is NULL\n"), VERR_INVALID_STATE);
rc = RTReqCall(pThis->pQueueRequests, &pReq, 10000 /* 10 sec. */, (PFNRT)drvscsiAsyncIOLoopWakeupFunc, 0);
AssertMsgRC(rc, ("Inserting request into queue failed rc=%Rrc\n", rc));
return rc;
}
/* -=-=-=-=- ISCSIConnector -=-=-=-=- */
/** @copydoc PDMISCSICONNECTOR::pfnSCSIRequestSend. */
static DECLCALLBACK(int) drvscsiRequestSend(PPDMISCSICONNECTOR pInterface, PPDMSCSIREQUEST pSCSIRequest)
{
int rc;
PDRVSCSI pThis = PDMISCSICONNECTOR_2_DRVSCSI(pInterface);
PRTREQ pReq;
AssertMsgReturn(pThis->pQueueRequests, ("pQueueRequests is NULL\n"), VERR_INVALID_STATE);
rc = RTReqCallEx(pThis->pQueueRequests, &pReq, 0, RTREQFLAGS_NO_WAIT, (PFNRT)drvscsiProcessRequestOne, 2, pThis, pSCSIRequest);
AssertMsgReturn(RT_SUCCESS(rc), ("Inserting request into queue failed rc=%Rrc\n", rc), rc);
return VINF_SUCCESS;
}
/* -=-=-=-=- IBase -=-=-=-=- */
/** @copydoc PDMIBASE::pfnQueryInterface. */
static DECLCALLBACK(void *) drvscsiQueryInterface(PPDMIBASE pInterface, PDMINTERFACE enmInterface)
{
PPDMDRVINS pDrvIns = PDMIBASE_2_PDMDRV(pInterface);
PDRVSCSI pThis = PDMINS_2_DATA(pDrvIns, PDRVSCSI);
switch (enmInterface)
{
case PDMINTERFACE_BASE:
return &pDrvIns->IBase;
case PDMINTERFACE_SCSI_CONNECTOR:
return &pThis->ISCSIConnector;
case PDMINTERFACE_BLOCK_PORT:
return &pThis->IPort;
default:
return NULL;
}
}
/**
* Destruct a driver instance.
*
* Most VM resources are freed by the VM. This callback is provided so that any non-VM
* resources can be freed correctly.
*
* @param pDrvIns The driver instance data.
*/
static DECLCALLBACK(void) drvscsiDestruct(PPDMDRVINS pDrvIns)
{
int rc;
PDRVSCSI pThis = PDMINS_2_DATA(pDrvIns, PDRVSCSI);
if (pThis->pQueueRequests)
{
rc = RTReqDestroyQueue(pThis->pQueueRequests);
AssertMsgRC(rc, ("Failed to destroy queue rc=%Rrc\n", rc));
}
}
/**
* Construct a block driver instance.
*
* @returns VBox status.
* @param pDrvIns The driver instance data.
* If the registration structure is needed, pDrvIns->pDrvReg points to it.
* @param pCfgHandle Configuration node handle for the driver. Use this to obtain the configuration
* of the driver instance. It's also found in pDrvIns->pCfgHandle, but like
* iInstance it's expected to be used a bit in this function.
*/
static DECLCALLBACK(int) drvscsiConstruct(PPDMDRVINS pDrvIns, PCFGMNODE pCfgHandle)
{
int rc = VINF_SUCCESS;
PDMBLOCKTYPE enmType;
PDRVSCSI pThis = PDMINS_2_DATA(pDrvIns, PDRVSCSI);
LogFlowFunc(("pDrvIns=%#p pCfgHandle=%#p\n", pDrvIns, pCfgHandle));
/*
* Initialize interfaces.
*/
pDrvIns->IBase.pfnQueryInterface = drvscsiQueryInterface;
pThis->ISCSIConnector.pfnSCSIRequestSend = drvscsiRequestSend;
/*
* Try attach driver below and query it's block interface.
*/
rc = pDrvIns->pDrvHlp->pfnAttach(pDrvIns, &pThis->pDrvBase);
AssertMsgReturn(RT_SUCCESS(rc), ("Attaching driver below failed rc=%Rrc\n", rc), rc);
/*
* Query the block and blockbios interfaces.
*/
pThis->pDrvBlock = (PDMIBLOCK *)pThis->pDrvBase->pfnQueryInterface(pThis->pDrvBase, PDMINTERFACE_BLOCK);
if (!pThis->pDrvBlock)
{
AssertMsgFailed(("Configuration error: No block interface!\n"));
return VERR_PDM_MISSING_INTERFACE;
}
pThis->pDrvBlockBios = (PDMIBLOCKBIOS *)pThis->pDrvBase->pfnQueryInterface(pThis->pDrvBase, PDMINTERFACE_BLOCK_BIOS);
if (!pThis->pDrvBlockBios)
{
AssertMsgFailed(("Configuration error: No block BIOS interface!\n"));
return VERR_PDM_MISSING_INTERFACE;
}
/* Query the SCSI port interface above. */
pThis->pDevScsiPort = (PPDMISCSIPORT)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_SCSI_PORT);
AssertMsgReturn(pThis->pDevScsiPort, ("Missing SCSI port interface above\n"), VERR_PDM_MISSING_INTERFACE);
pThis->pDrvMount = (PDMIMOUNT *)pThis->pDrvBase->pfnQueryInterface(pThis->pDrvBase, PDMINTERFACE_MOUNT);
/* Query the optional LED interface above. */
pThis->pLedPort = (PPDMILEDPORTS)pDrvIns->pUpBase->pfnQueryInterface(pDrvIns->pUpBase, PDMINTERFACE_LED_PORTS);
if (pThis->pLedPort != NULL)
{
/* Get The Led. */
rc = pThis->pLedPort->pfnQueryStatusLed(pThis->pLedPort, 0, &pThis->pLed);
if (RT_FAILURE(rc))
pThis->pLed = &pThis->Led;
}
else
pThis->pLed = &pThis->Led;
/* Try to get the optional async block interface. */
pThis->pDrvBlockAsync = (PDMIBLOCKASYNC *)pThis->pDrvBase->pfnQueryInterface(pThis->pDrvBase, PDMINTERFACE_BLOCK_ASYNC);
enmType = pThis->pDrvBlock->pfnGetType(pThis->pDrvBlock);
if (enmType != PDMBLOCKTYPE_HARD_DISK)
{
AssertMsgFailed(("Configuration error: Not a disk or cd/dvd-rom. enmType=%d\n", enmType));
return VERR_PDM_UNSUPPORTED_BLOCK_TYPE;
}
pThis->enmType = enmType;
pThis->cSectors = pThis->pDrvBlock->pfnGetSize(pThis->pDrvBlock) / 512;
/* Create request queue. */
rc = RTReqCreateQueue(&pThis->pQueueRequests);
AssertMsgReturn(RT_SUCCESS(rc), ("Failed to create request queue rc=%Rrc\n"), rc);
/* Register statistics counter. */
PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatBytesRead, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES,
"Amount of data read.", "/Devices/SCSI/%d/ReadBytes", pDrvIns->iInstance);
PDMDrvHlpSTAMRegisterF(pDrvIns, &pThis->StatBytesWritten, STAMTYPE_COUNTER, STAMVISIBILITY_ALWAYS, STAMUNIT_BYTES,
"Amount of data written.", "/Devices/SCSI/%d/WrittenBytes", pDrvIns->iInstance);
/* Create I/O thread. */
rc = PDMDrvHlpPDMThreadCreate(pDrvIns, &pThis->pAsyncIOThread, pThis, drvscsiAsyncIOLoop,
drvscsiAsyncIOLoopWakeup, 0, RTTHREADTYPE_IO, "SCSI async IO");
AssertMsgReturn(RT_SUCCESS(rc), ("Failed to create async I/O thread rc=%Rrc\n"), rc);
return VINF_SUCCESS;
}
/**
* SCSI driver registration record.
*/
const PDMDRVREG g_DrvSCSI =
{
/* u32Version */
PDM_DRVREG_VERSION,
/* szDriverName */
"SCSI",
/* pszDescription */
"Generic SCSI driver.",
/* fFlags */
PDM_DRVREG_FLAGS_HOST_BITS_DEFAULT,
/* fClass. */
PDM_DRVREG_CLASS_SCSI,
/* cMaxInstances */
~0,
/* cbInstance */
sizeof(DRVSCSI),
/* pfnConstruct */
drvscsiConstruct,
/* pfnDestruct */
drvscsiDestruct,
/* pfnIOCtl */
NULL,
/* pfnPowerOn */
NULL,
/* pfnReset */
NULL,
/* pfnSuspend */
NULL,
/* pfnResume */
NULL,
/* pfnDetach */
NULL,
/* pfnPowerOff */
NULL
};