ScsiDisk.h

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
#ifndef SCSIDISK_H
#define SCSIDISK_H
#include "pedigree/kernel/TargetInfo.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/machine/Disk.h"
#include "pedigree/kernel/process/Mutex.h"
#include "pedigree/kernel/process/OperationBarrier.h"
#include "pedigree/kernel/process/TerminationDeferral.h"
#include "pedigree/kernel/process/Thread.h"
#include "pedigree/kernel/process/WaitQueue.h"
#include "pedigree/kernel/processor/PhysicalMemoryManager.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/Cache.h"
#include "pedigree/kernel/utilities/CacheConstants.h"
#include "pedigree/kernel/utilities/String.h"
#include "pedigree/kernel/utilities/Vector.h"
 
#include <config.h>
 
class ScsiCommand;
 
class EXPORTED_PUBLIC ScsiDisk : public Disk {
 private:
  enum ScsiPeripheralType {
    BlockDevice = 0x00,
    SequentialDevice = 0x01,
    PrinterDevice = 0x02,
    ProcessorDevice = 0x03,
    WriteOnceDevice = 0x04,
    CdDvdDevice = 0x05,
    OpticalMemoryDevice = 0x07,
    MediumChangerDevice = 0x08,
    ArrayDevice = 0x0C,
    EnclosureDevice = 0x0D,
    NoDevice = 0x1F,
  };
 
 public:
  struct Sense {
    uint8_t ResponseCode;
    uint8_t Obsolete;
    uint32_t SenseKey : 4;
    uint32_t rsvd : 1;
    uint32_t ili : 1;
    uint32_t eom : 1;
    uint32_t filemark : 1;
    uint32_t info;
    uint8_t addLen;
    uint32_t commandInfo;
    uint8_t Asc;
    uint8_t AscQ;
    uint8_t fieldCode;
    uint8_t senseKeySpecific[3];
  } PACKED;
 
  struct Inquiry {
    uint8_t Peripheral;
    uint8_t Removable;
    uint8_t Version;
    uint8_t Flags1;
    uint8_t AddLength;
    uint8_t Rsvd[2];
    uint8_t Flags2;
    uint8_t VendIdent[8];
    uint8_t ProdIdent[16];
    uint8_t ProdRev[4];
  } PACKED;
 
  struct Capacity {
    uint32_t LBA;
    uint32_t BlockSize;
  } PACKED;
 
  explicit ScsiDisk(size_t cacheConstraints = PhysicalMemoryManager::below4GB);
  virtual ~ScsiDisk();
 
#if HOSTED && PEDIGREE_HOSTED_SMOKE_TESTS
  using HostedReadRequestHook = void (*)(ScsiDisk*, uint64_t, void*);
  static void setHostedReadRequestHookForTest(HostedReadRequestHook hook, void* context);
#endif
 
  void shutdownCache(bool deviceAvailable = true);
  virtual void shutdownDeviceCache();
  bool hasNoCacheLoans();
 
  bool initialise(class ScsiController* pController, size_t nUnit);
 
  virtual BufferView read(uint64_t location);
  bool readInto(uint64_t location, void* buffer, size_t length) override;
  bool readIntoBatch(ReadBuffer* buffers, size_t count) override;
  bool writeFrom(uint64_t location, const void* buffer, size_t length) override;
  bool writeFromBatch(WriteBuffer* buffers, size_t count) override;
  bool syncData() override;
  virtual void write(uint64_t location);
  virtual void flush(uint64_t location);
  virtual bool sync(uint64_t location, bool async);
  MUST_USE_RESULT virtual bool syncAll();
  bool zero(uint64_t location, size_t length) override;
  bool syncPages(const uint64_t* locations, size_t count) override;
  MUST_USE_RESULT virtual bool retireCachePage(uint64_t location);
  virtual void align(uint64_t location);
 
  virtual void getName(String& str) {
    str = String("SCSI Disk");
  }
 
  // These are the internal functions that the controller calls when it is
  // ready to process our request.
  virtual uint64_t doRead(uint64_t location);
  virtual uint64_t doWrite(uint64_t location);
  virtual uint64_t doWriteDirectPhysical(uint64_t location, uintptr_t page,
                                         physical_uintptr_t physical);
  virtual uint64_t doSync(uint64_t location);
  virtual PagingStatus doPagingTransfer(PagingOperation operation, uint64_t offset, void* page);
 
  // This value is outside every valid byte location, including a maximal disk.
  // It is reserved for SCSI_REQUEST_SYNC and never enters cache page arithmetic.
  static constexpr uint64_t SyncWholeDevice = ~uint64_t{0};
 
  virtual size_t getSize() const {
    return m_NumBlocks * m_NativeBlockSize;
  }
 
  virtual size_t getBlockCount() const {
    return m_NumBlocks;
  }
 
  virtual size_t getBlockSize() const {
    return m_BlockSize;
  }
 
  virtual size_t getNativeBlockSize() const {
    return m_NativeBlockSize;
  }
 
  virtual bool pin(uint64_t location);
  virtual void unpin(uint64_t location);
 
 protected:
  BufferView acquireView(uint64_t location, bool writable, uint64_t& token) override;
  void releaseView(uint64_t token, bool writable) override;
 
  virtual bool supportsBufferTransfers() const {
    return false;
  }
  virtual bool supportsDirectCacheWrite() const {
    return false;
  }
  virtual Device* dmaDevice() const {
    return nullptr;
  }
  virtual bool transferBuffer(uint64_t location, void* buffer, size_t length, bool writing);
  virtual bool transferReadBuffers(ReadBuffer* buffers, size_t count);
  virtual bool transferWriteBuffers(WriteBuffer* buffers, size_t count);
  static bool syncCacheBatch(const Cache::WritebackPage* pages, size_t count, void* context);
 
  ScsiController* acquirePagingController(OperationBarrier::Lease& use);
  PagingStatus preparePagingCache(PagingTransport& transport);
 
  virtual size_t getCacheFillSize() const {
    return TargetInfo::getPageSize();
  }
 
  size_t getCacheFillLength(uint64_t location) const;
 
  Cache& getCache() {
    return m_Cache;
  }
 
  Inquiry* getInquiry() const {
    return m_Inquiry;
  }
 
 private:
  class CacheRangeAdmission {
   public:
    CacheRangeAdmission(ScsiDisk& disk, uint64_t start, size_t length, bool retire);
    ~CacheRangeAdmission();
 
   private:
    friend class ScsiDisk;
 
    NOT_COPYABLE_OR_ASSIGNABLE(CacheRangeAdmission);
 
    static void discard(void* context);
 
    ScsiDisk& m_Disk;
    uint64_t m_Start;
    size_t m_Length;
    bool m_Retire;
    bool m_Linked;
    CacheRangeAdmission* m_Previous;
    CacheRangeAdmission* m_Next;
    TerminationDeferral m_TerminationDeferral;
    Thread::StackDiscardScope m_StackDiscardScope;
  };
 
  void enterCacheRange(CacheRangeAdmission& admission);
  void leaveCacheRange(CacheRangeAdmission& admission);
  bool cacheRangeBlocked(const CacheRangeAdmission& admission) const;
  bool transferBufferRange(uint64_t location, void* buffer, size_t length, bool writing);
  static bool cacheRangesOverlap(uint64_t firstStart, size_t firstLength, uint64_t secondStart,
                                 size_t secondLength);
 
  bool unitReady();
 
  bool readSense(Sense* s);
 
  bool sendCommand(ScsiCommand* pCommand, uintptr_t pRespBuffer, uint16_t nRespBytes,
                   bool bWrite = false);
 
  bool getCapacityInternal(size_t* blockNumber, size_t* blockSize);
 
  bool flushCachePage(uint64_t location, uintptr_t page);
 
  bool writePageBuffer(uint64_t location, uintptr_t page);
 
  size_t getCachePageValidLength(uint64_t location) const;
 
  static bool retireCachePageCallback(uintptr_t key, uintptr_t page, void* meta);
 
  uint64_t getAlignmentPoint(uint64_t location) const;
  bool hasShiftedCacheAlignment() const;
 
  static bool cacheCallback(CacheConstants::CallbackCause cause, uintptr_t loc, uintptr_t page,
                            void* meta);
 
  class ScsiController* m_pController;
  size_t m_nUnit;
 
  Cache m_Cache;
  Inquiry* m_Inquiry;
 
  WaitQueue m_CacheRangeWaiters;
  CacheRangeAdmission* m_FirstCacheRangeAdmission;
  CacheRangeAdmission* m_LastCacheRangeAdmission;
 
#if HOSTED && PEDIGREE_HOSTED_SMOKE_TESTS
  static Mutex m_HostedReadRequestHookLock;
  static HostedReadRequestHook m_HostedReadRequestHook;
  static void* m_HostedReadRequestHookContext;
#endif
 
  mutable Mutex m_AlignmentLock;
  Vector<uint64_t> m_AlignPoints;
  bool m_HasShiftedCacheAlignment;
 
  size_t m_NumBlocks;
  size_t m_BlockSize;
  size_t m_NativeBlockSize;
 
  ScsiPeripheralType m_DeviceType;
 
  virtual size_t defaultBlockSize() {
    return m_BlockSize;
  }
 
 public:
  MUST_USE_RESULT virtual uint64_t doWriteDirect(uint64_t location, uintptr_t page);
};
 
#endif