scsi-write-regressions.cc

/*
 * Copyright (c) 2026, Pedigree Developers
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted.
 */
 
#include "pedigree/kernel/Atomic.h"
#include "pedigree/kernel/Log.h"
#include "pedigree/kernel/TargetInfo.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/process/Scheduler.h"
#include "pedigree/kernel/process/Semaphore.h"
#include "pedigree/kernel/process/Thread.h"
#include "pedigree/kernel/time/Time.h"
#include "pedigree/kernel/utilities/Cache.h"
#include "pedigree/kernel/utilities/utility.h"
 
#include "modules/drivers/common/ata/AtaWriteCache.h"
#include "modules/drivers/common/scsi/ScsiController.h"
#include "modules/drivers/common/scsi/ScsiDisk.h"
 
namespace {
constexpr size_t PageBytes = TargetInfo::getPageSize();
constexpr uint64_t AtaOwnershipLocation = 0;
constexpr uint64_t AtaDrainingLocation = PageBytes;
constexpr uint64_t FailedWriteLocation = 2 * PageBytes;
constexpr uint64_t SuccessfulWriteLocation = 3 * PageBytes;
constexpr uint64_t MissingDirectLocation = 4 * PageBytes;
constexpr uint64_t EditingDirectLocation = 5 * PageBytes;
constexpr uint64_t SuccessfulDirectLocation = 6 * PageBytes;
constexpr uint64_t FailedDirectLocation = 7 * PageBytes;
constexpr uint64_t UnreadyDirectLocation = 8 * PageBytes;
constexpr uint64_t ShortDirectLocation = 9 * PageBytes;
constexpr uint64_t PinnedDirectLocation = 10 * PageBytes;
constexpr uint64_t CancelledDirectLocation = 11 * PageBytes;
constexpr uint64_t CanonicalDirectLocation = 12 * PageBytes;
constexpr uint64_t CheckedSyncLocation = 13 * PageBytes;
constexpr uint64_t ReadFirstLocation = 16 * PageBytes;
constexpr uint64_t RejectedReadLocation = 18 * PageBytes;
constexpr uint64_t RetireFirstExtent = 24 * PageBytes;
constexpr uint64_t RetireFirstInterior = RetireFirstExtent + PageBytes;
constexpr uint64_t NonoverlapReadLocation = 28 * PageBytes;
constexpr uint64_t RecheckReadLocation = 32 * PageBytes;
constexpr uint64_t LookupPauseLocation = 36 * PageBytes;
constexpr uint8_t CdDvdPeripheral = 0x05;
 
enum class WriteMode { Initialising, FailAll, PassWrite12, UnitNotReady };
enum class SyncMode { Pass10, Pass16, FailAll, FailWhole };
enum class RequestEvent : uint8_t { Read = 1, Direct = 2 };
 
class ScriptedScsiController final : public ScsiController {
 public:
  explicit ScriptedScsiController(size_t capacityBytes = 64 * PageBytes,
                                  size_t nativeBlockBytes = 512, bool optical = false)
      : ScsiController(),
        m_Mode(WriteMode::Initialising),
        m_WriteOpcodes(),
        m_WriteCount(0),
        m_SyncMode(SyncMode::Pass10),
        m_SyncOpcodes(),
        m_SyncWhole(),
        m_SyncCount(0),
        m_WritesAtLastSync(0),
        m_HoldNextSync(0),
        m_SyncEntered(0, false),
        m_SyncRelease(0, false),
        m_SyncRequestLocations(),
        m_SyncRequestCount(0),
        m_UnitReadyCount(0),
        m_LastWriteBuffer(0),
        m_DirectRequestCount(0),
        m_DirectDisk(0),
        m_DirectLocation(0),
        m_DirectPage(0),
        m_HoldNextRead(0),
        m_ReadHoldsRemaining(0),
        m_DelegateHeldRead(0),
        m_ReadEntered(0, false),
        m_ReadRelease(0, false),
        m_ReadRequestCount(0),
        m_ReadCommandCount(0),
        m_ReadTocCount(0),
        m_LastReadOpcode(0),
        m_RequestEvents(),
        m_RequestEventCount(0),
        m_CapacityBytes(capacityBytes),
        m_NativeBlockBytes(nativeBlockBytes),
        m_Optical(optical),
        m_LastReadBytes(0),
        m_LastWriteBytes(0),
        m_Valid(true) {}
 
  bool sendCommand(size_t nUnit, uintptr_t pCommand, uint8_t nCommandSize, uintptr_t pRespBuffer,
                   uint16_t nRespBytes, bool bWrite) override {
    if (nUnit || !pCommand || !nCommandSize) {
      m_Valid = false;
      return false;
    }
 
    const uint8_t opcode = *reinterpret_cast<const uint8_t*>(pCommand);
    switch (opcode) {
      case 0x00:
        if (bWrite || pRespBuffer || nRespBytes || nCommandSize != 6) {
          m_Valid = false;
          return false;
        }
        if (m_Mode != WriteMode::Initialising)
          ++m_UnitReadyCount;
        return m_Mode != WriteMode::UnitNotReady;
      case 0x12: {
        if (bWrite || !pRespBuffer || nRespBytes != sizeof(ScsiDisk::Inquiry) ||
            nCommandSize != 6) {
          m_Valid = false;
          return false;
        }
        auto* inquiry = reinterpret_cast<ScsiDisk::Inquiry*>(pRespBuffer);
        ByteSet(inquiry, 0, sizeof(*inquiry));
        inquiry->Peripheral = m_Optical ? CdDvdPeripheral : 0;
        return true;
      }
      case 0x25: {
        if (bWrite || !pRespBuffer || nRespBytes != sizeof(ScsiDisk::Capacity) ||
            nCommandSize != 10 || !m_NativeBlockBytes || !m_CapacityBytes ||
            (m_CapacityBytes % m_NativeBlockBytes)) {
          m_Valid = false;
          return false;
        }
        auto* capacity = reinterpret_cast<ScsiDisk::Capacity*>(pRespBuffer);
        capacity->LBA =
            HOST_TO_BIG32(static_cast<uint32_t>((m_CapacityBytes / m_NativeBlockBytes) - 1));
        capacity->BlockSize = HOST_TO_BIG32(static_cast<uint32_t>(m_NativeBlockBytes));
        return true;
      }
      case 0x43: {
        if (!m_Optical || bWrite || !pRespBuffer || nRespBytes != m_NativeBlockBytes ||
            nCommandSize != 10) {
          m_Valid = false;
          return false;
        }
 
        auto* toc = reinterpret_cast<uint8_t*>(pRespBuffer);
        ByteSet(toc, 0, nRespBytes);
        toc[1] = 10;  // Header plus one eight-byte track descriptor.
        toc[2] = 1;
        toc[3] = 1;
        toc[5] = 0x14;  // ADR=1, data track.
        toc[6] = 1;
        m_ReadTocCount += 1;
        return true;
      }
      case 0x28:
      case 0xa8:
      case 0x88:
        return handleRead(opcode, nCommandSize, pRespBuffer, nRespBytes, bWrite);
      case 0x2a:
      case 0xaa:
      case 0x8a:
        return handleWrite(opcode, nCommandSize, pRespBuffer, nRespBytes, bWrite);
      case 0x35:
      case 0x91: {
        if (bWrite || pRespBuffer || nRespBytes || nCommandSize != (opcode == 0x35 ? 10 : 16) ||
            m_SyncCount >= sizeof(m_SyncOpcodes)) {
          m_Valid = false;
          return false;
        }
        const uint8_t* command = reinterpret_cast<const uint8_t*>(pCommand);
        bool whole = true;
        for (size_t i = 1; i < nCommandSize; ++i) {
          whole = whole && command[i] == 0;
        }
        m_WritesAtLastSync = m_WriteCount;
        m_SyncWhole[m_SyncCount] = whole;
        m_SyncOpcodes[m_SyncCount++] = opcode;
        if (m_HoldNextSync.compareAndSwap(1, 0)) {
          m_SyncEntered.release();
          if (!m_SyncRelease.acquireForCompletion()) {
            m_Valid = false;
            return false;
          }
        }
        return m_SyncMode == SyncMode::Pass10 ||
               (m_SyncMode == SyncMode::Pass16 && opcode == 0x91) ||
               (m_SyncMode == SyncMode::FailWhole && !whole);
      }
      default:
        m_Valid = false;
        return false;
    }
  }
 
  void beginWrites(WriteMode mode) {
    m_Mode = mode;
    m_WriteCount = 0;
    m_UnitReadyCount = 0;
    m_LastWriteBuffer = 0;
    m_DirectRequestCount = 0;
    m_DirectDisk = 0;
    m_DirectLocation = 0;
    m_DirectPage = 0;
    m_LastWriteBytes = 0;
    m_SyncCount = 0;
    m_WritesAtLastSync = 0;
    m_SyncRequestCount = 0;
  }
 
  void beginSync(SyncMode mode) {
    m_SyncMode = mode;
    m_SyncCount = 0;
    m_WritesAtLastSync = 0;
    m_SyncRequestCount = 0;
  }
 
  void holdNextSync() {
    m_HoldNextSync = 1;
  }
 
  bool waitForHeldSync() {
    return m_SyncEntered.acquireForCompletion(1, 0, 500000);
  }
 
  void releaseHeldSync() {
    m_HoldNextSync = 0;
    m_SyncRelease.release();
  }
 
  bool syncTraceMatches(const uint8_t* expected, size_t count) const {
    return m_Valid && m_SyncCount == count && !MemoryCompare(m_SyncOpcodes, expected, count);
  }
 
  bool syncGeometryMatches(const bool* whole, size_t count) const {
    return m_Valid && m_SyncCount == count &&
           !MemoryCompare(m_SyncWhole, whole, count * sizeof(bool));
  }
 
  bool syncRequestsMatch(const uint64_t* locations, size_t count) const {
    return m_Valid && m_SyncRequestCount == count &&
           !MemoryCompare(m_SyncRequestLocations, locations, count * sizeof(uint64_t));
  }
 
  void beginRequestTrace() {
    m_ReadRequestCount = 0;
    m_ReadCommandCount = 0;
    m_ReadTocCount = 0;
    m_LastReadOpcode = 0;
    m_RequestEventCount = 0;
    m_LastReadBytes = 0;
  }
 
  void holdNextRead() {
    const size_t staleEntries = m_ReadEntered.drainAvailable();
    const size_t staleReleases = m_ReadRelease.drainAvailable();
    (void)staleEntries;
    (void)staleReleases;
    m_DelegateHeldRead = 0;
    m_HoldNextRead = 1;
    m_ReadHoldsRemaining = 1;
  }
 
  void holdFollowingRead() {
    m_ReadHoldsRemaining += 1;
  }
 
  bool waitForHeldRead() {
    return m_ReadEntered.acquireForCompletion(1, 0, 500000);
  }
 
  void releaseHeldRead(bool delegate) {
    m_DelegateHeldRead = delegate ? 1 : 0;
    m_ReadRelease.release();
  }
 
  void disarmReadHold() {
    m_ReadHoldsRemaining = 0;
    m_HoldNextRead = 0;
    const size_t staleEntries = m_ReadEntered.drainAvailable();
    const size_t staleReleases = m_ReadRelease.drainAvailable();
    m_ReadRelease.release();
    (void)staleEntries;
    (void)staleReleases;
  }
 
  size_t readRequestCount() const {
    return m_ReadRequestCount.value();
  }
 
  size_t readCommandCount() const {
    return m_ReadCommandCount.value();
  }
 
  size_t readTocCount() const {
    return m_ReadTocCount.value();
  }
 
  uint8_t lastReadOpcode() const {
    return m_LastReadOpcode;
  }
 
  size_t directRequestCount() const {
    return m_DirectRequestCount;
  }
 
  bool requestTraceMatches(const RequestEvent* expected, size_t count) const {
    return m_Valid && m_RequestEventCount == count &&
           !MemoryCompare(m_RequestEvents, expected, count * sizeof(RequestEvent));
  }
 
  bool writeTraceMatches(const uint8_t* expected, size_t count) const {
    return m_Valid && m_WriteCount == count && !MemoryCompare(m_WriteOpcodes, expected, count);
  }
 
  bool directTupleMatches(const ScsiDisk* disk, uint64_t location, uintptr_t page) const {
    return m_Valid && m_DirectRequestCount == 1 &&
           m_DirectDisk == reinterpret_cast<uint64_t>(disk) && m_DirectLocation == location &&
           m_DirectPage == page;
  }
 
  bool hasNoDirectActivity() const {
    return m_Valid && !m_DirectRequestCount && !m_UnitReadyCount && !m_WriteCount;
  }
 
  size_t unitReadyCount() const {
    return m_UnitReadyCount;
  }
 
  size_t writeCount() const {
    return m_WriteCount;
  }
 
  size_t writesAtLastSync() const {
    return m_WritesAtLastSync;
  }
 
  uintptr_t lastWriteBuffer() const {
    return m_LastWriteBuffer;
  }
 
  size_t lastReadBytes() const {
    return m_LastReadBytes;
  }
 
  size_t lastWriteBytes() const {
    return m_LastWriteBytes;
  }
 
  uint64_t executeRequest(uint64_t p1, uint64_t p2, uint64_t p3, uint64_t p4, uint64_t p5,
                          uint64_t p6, uint64_t p7, uint64_t p8) override {
    if (p1 == SCSI_REQUEST_READ) {
      appendRequestEvent(RequestEvent::Read);
      m_ReadRequestCount += 1;
      size_t remaining = m_ReadHoldsRemaining.value();
      bool hold = false;
      while (remaining && !hold) {
        hold = m_ReadHoldsRemaining.compareAndSwap(remaining, remaining - 1);
        remaining = m_ReadHoldsRemaining.value();
      }
      if (hold) {
        m_HoldNextRead = 2;
        m_ReadEntered.release();
        if (!m_ReadRelease.acquireForCompletion()) {
          m_Valid = false;
          m_HoldNextRead = 0;
          return 0;
        }
        const bool delegate = static_cast<size_t>(m_DelegateHeldRead) != 0;
        m_HoldNextRead = 0;
        if (!delegate)
          return 0;
      }
    }
    if (p1 == SCSI_REQUEST_SYNC) {
      if (m_SyncRequestCount >=
          sizeof(m_SyncRequestLocations) / sizeof(m_SyncRequestLocations[0])) {
        m_Valid = false;
        return 0;
      }
      m_SyncRequestLocations[m_SyncRequestCount++] = p3;
    }
    if (p1 == SCSI_REQUEST_WRITE_DIRECT) {
      appendRequestEvent(RequestEvent::Direct);
      ++m_DirectRequestCount;
      m_DirectDisk = p2;
      m_DirectLocation = p3;
      m_DirectPage = p4;
    }
    return ScsiController::executeRequest(p1, p2, p3, p4, p5, p6, p7, p8);
  }
 
 protected:
  size_t getNumUnits() override {
    return 1;
  }
 
 private:
  bool handleRead(uint8_t opcode, uint8_t commandSize, uintptr_t response, uint16_t responseBytes,
                  bool write) {
    const uint8_t expectedSize = opcode == 0x28 ? 10 : (opcode == 0xa8 ? 12 : 16);
    if (write || !response || !responseBytes || (responseBytes % m_NativeBlockBytes) ||
        commandSize != expectedSize) {
      m_Valid = false;
      return false;
    }
 
    ByteSet(reinterpret_cast<void*>(response), 0x3c, responseBytes);
    m_LastReadBytes = responseBytes;
    m_LastReadOpcode = opcode;
    m_ReadCommandCount += 1;
    return true;
  }
 
  bool handleWrite(uint8_t opcode, uint8_t commandSize, uintptr_t response, uint16_t responseBytes,
                   bool write) {
    const uint8_t expectedSize = opcode == 0x2a ? 10 : (opcode == 0xaa ? 12 : 16);
    if (m_Mode == WriteMode::Initialising || !write || !response || !responseBytes ||
        (responseBytes % m_NativeBlockBytes) || commandSize != expectedSize ||
        m_WriteCount >= sizeof(m_WriteOpcodes)) {
      m_Valid = false;
      return false;
    }
 
    m_WriteOpcodes[m_WriteCount++] = opcode;
    m_LastWriteBuffer = response;
    m_LastWriteBytes = responseBytes;
    return m_Mode == WriteMode::PassWrite12 && opcode == 0xaa;
  }
 
  void appendRequestEvent(RequestEvent event) {
    if (m_RequestEventCount >= sizeof(m_RequestEvents) / sizeof(m_RequestEvents[0])) {
      m_Valid = false;
      return;
    }
    m_RequestEvents[m_RequestEventCount++] = event;
  }
 
  WriteMode m_Mode;
  uint8_t m_WriteOpcodes[32];
  size_t m_WriteCount;
  SyncMode m_SyncMode;
  uint8_t m_SyncOpcodes[8];
  bool m_SyncWhole[8];
  size_t m_SyncCount;
  size_t m_WritesAtLastSync;
  Atomic<size_t> m_HoldNextSync;
  Semaphore m_SyncEntered;
  Semaphore m_SyncRelease;
  uint64_t m_SyncRequestLocations[8];
  size_t m_SyncRequestCount;
  size_t m_UnitReadyCount;
  uintptr_t m_LastWriteBuffer;
  size_t m_DirectRequestCount;
  uint64_t m_DirectDisk;
  uint64_t m_DirectLocation;
  uintptr_t m_DirectPage;
  Atomic<size_t> m_HoldNextRead;
  Atomic<size_t> m_ReadHoldsRemaining;
  Atomic<size_t> m_DelegateHeldRead;
  Semaphore m_ReadEntered;
  Semaphore m_ReadRelease;
  Atomic<size_t> m_ReadRequestCount;
  Atomic<size_t> m_ReadCommandCount;
  Atomic<size_t> m_ReadTocCount;
  uint8_t m_LastReadOpcode;
  RequestEvent m_RequestEvents[16];
  size_t m_RequestEventCount;
  size_t m_CapacityBytes;
  size_t m_NativeBlockBytes;
  bool m_Optical;
  size_t m_LastReadBytes;
  size_t m_LastWriteBytes;
  bool m_Valid;
};
 
class HostedScsiDisk final : public ScsiDisk {
 public:
  HostedScsiDisk()
      : ScsiDisk(),
        m_OverrideDirectResult(false),
        m_DirectResult(0),
        m_ObserveUnpin(false),
        m_UnpinCalls(0),
        m_LastUnpinLocation(0),
        m_CacheFillSize(PageBytes),
        m_BufferTransfersEnabled(false),
        m_BufferTransferCount(0) {}
 
  bool preparePage(uint64_t location) {
    bool alreadyExisted = false;
    const uintptr_t buffer = getCache().insert(location, &alreadyExisted);
    if (!buffer || alreadyExisted)
      return false;
    ByteSet(reinterpret_cast<void*>(buffer), 0x5a, PageBytes);
    getCache().markNoLongerEditing(location);
    return true;
  }
 
  bool prepareEditingPage(uint64_t location) {
    bool alreadyExisted = false;
    return getCache().insert(location, &alreadyExisted) && !alreadyExisted;
  }
 
  bool discardEditingPage(uint64_t location) {
    return getCache().discardEditing(location);
  }
 
  bool takeAtaQueuedWritePage(uint64_t location) {
    const uintptr_t buffer = ataTakeQueuedWritePage(getCache(), location);
    if (!buffer)
      return false;
    CachePageGuard guard(getCache(), location);
    return true;
  }
 
  bool missesAtaQueuedWritePage(uint64_t location) {
    const uintptr_t buffer = ataTakeQueuedWritePage(getCache(), location);
    if (buffer) {
      CachePageGuard guard(getCache(), location);
      return false;
    }
    return true;
  }
 
  bool evictPage(uint64_t location) {
    return getCache().evict(location);
  }
 
  void checksumPage(uint64_t location) {
    getCache().triggerChecksum(location);
  }
 
  void pauseBackgroundWriteback() {
    getCache().startAtomic();
  }
 
  void resumeBackgroundWriteback() {
    getCache().endAtomic();
  }
 
  bool runBackgroundWriteback() {
    getCache().timer(CACHE_WRITEBACK_PERIOD * 1000000ULL);
    return CacheManager::instance().drain();
  }
 
  bool evictRange(uint64_t location, size_t length) {
    bool evicted = true;
    for (size_t offset = 0; offset < length; offset += PageBytes) {
      if (hasPage(location + offset) && !getCache().evict(location + offset))
        evicted = false;
    }
    return evicted;
  }
 
  bool retirePage(uint64_t location, Cache::retirement_writeback_t callback, void* context) {
    return getCache().retireWriteback(location, callback, context);
  }
 
  bool hasPage(uint64_t location) {
    return getCache().exists(location, PageBytes);
  }
 
  uintptr_t pageAddress(uint64_t location) {
    const uintptr_t page = getCache().lookup(location);
    if (page)
      getCache().release(location);
    return page;
  }
 
  void overrideDirectResult(uint64_t result) {
    m_DirectResult = result;
    m_OverrideDirectResult = true;
  }
 
  void restoreDirectResult() {
    m_OverrideDirectResult = false;
  }
 
  void setCacheFillSize(size_t fillSize) {
    m_CacheFillSize = fillSize;
  }
 
  void enableBufferTransfers() {
    m_BufferTransfersEnabled = true;
  }
 
  size_t bufferTransferCount() const {
    return m_BufferTransferCount;
  }
 
  void beginReadBufferBatch(uint64_t failedLocation = ~uint64_t{0}) {
    m_BufferTransferCount = 0;
    m_BufferBatchCount = 0;
    m_LastBufferBatchSize = 0;
    m_FailedBufferLocation = failedLocation;
  }
 
  size_t bufferBatchCount() const {
    return m_BufferBatchCount;
  }
 
  bool bufferBatchMatches(const uint64_t* locations, size_t count) const {
    return m_BufferBatchCount == 1 && m_LastBufferBatchSize == count &&
           !MemoryCompare(m_BufferBatchLocations, locations, count * sizeof(uint64_t));
  }
 
  void beginUnpinObservation() {
    m_UnpinCalls = 0;
    m_LastUnpinLocation = 0;
    m_ObserveUnpin = true;
  }
 
  size_t endUnpinObservation() {
    m_ObserveUnpin = false;
    return m_UnpinCalls;
  }
 
  uint64_t lastUnpinLocation() const {
    return m_LastUnpinLocation;
  }
 
  void unpin(uint64_t location) override {
    if (m_ObserveUnpin) {
      ++m_UnpinCalls;
      m_LastUnpinLocation = location;
      return;
    }
    ScsiDisk::unpin(location);
  }
 
  uint64_t doWriteDirect(uint64_t location, uintptr_t page) override {
    if (m_OverrideDirectResult)
      return m_DirectResult;
    return ScsiDisk::doWriteDirect(location, page);
  }
 
 protected:
  bool supportsBufferTransfers() const override {
    return m_BufferTransfersEnabled;
  }
 
  bool transferBuffer(uint64_t location, void* buffer, size_t length, bool writing) override {
    ++m_BufferTransferCount;
    if (!writing && location == m_FailedBufferLocation)
      return false;
    if (!writing)
      ByteSet(buffer, 0xa6, length);
    return true;
  }
 
  bool transferReadBuffers(ReadBuffer* buffers, size_t count) override {
    ++m_BufferBatchCount;
    m_LastBufferBatchSize = count;
    for (size_t i = 0; i < count; ++i)
      m_BufferBatchLocations[i] = buffers[i].location;
    return ScsiDisk::transferReadBuffers(buffers, count);
  }
 
  size_t getCacheFillSize() const override {
    return m_CacheFillSize;
  }
 
 private:
  bool m_OverrideDirectResult;
  uint64_t m_DirectResult;
  bool m_ObserveUnpin;
  size_t m_UnpinCalls;
  uint64_t m_LastUnpinLocation;
  size_t m_CacheFillSize;
  bool m_BufferTransfersEnabled;
  size_t m_BufferTransferCount;
  size_t m_BufferBatchCount = 0;
  size_t m_LastBufferBatchSize = 0;
  uint64_t m_BufferBatchLocations[Disk::MaxReadBuffers] = {};
  uint64_t m_FailedBufferLocation = ~uint64_t{0};
};
 
struct RetirementResult {
  bool balanced;
  bool cleaned;
};
 
RetirementResult retireAndRepair(HostedScsiDisk& disk, uint64_t location,
                                 bool repairOneTransferredPin) {
  if (disk.evictPage(location))
    return {true, true};
  if (!repairOneTransferredPin)
    return {false, false};
 
  disk.unpin(location);
  return {false, disk.evictPage(location)};
}
 
struct Fixture {
  Fixture() : controller(), disk(), ready(false) {
    ready = disk.initialise(&controller, 0);
  }
 
  ScriptedScsiController controller;
  HostedScsiDisk disk;
  bool ready;
};
 
bool waitUntilQueuedAt(Thread* thread, size_t debugState, uintptr_t debugAddress) {
  const Time::Timestamp deadline = Time::getTicks() + (500 * Time::Multiplier::Millisecond);
  while (Time::getTicks() < deadline) {
    Thread::WaitDebugInfo info = {};
    uintptr_t address = 0;
    if (thread->getWaitDebugInfo(info) && info.queue && info.queued &&
        thread->getDebugState(address) == debugState && address == debugAddress) {
      return true;
    }
    Scheduler::instance().yield();
  }
  return false;
}
 
bool waitUntilSet(Atomic<size_t>& value) {
  const Time::Timestamp deadline = Time::getTicks() + (500 * Time::Multiplier::Millisecond);
  while (Time::getTicks() < deadline) {
    if (static_cast<size_t>(value))
      return true;
    Scheduler::instance().yield();
  }
  return static_cast<size_t>(value) != 0;
}
 
bool waitForAdmissionOrRead(Thread* thread, uint64_t location, ScriptedScsiController& controller,
                            size_t priorReadCount, bool& admissionWait) {
  const Time::Timestamp deadline = Time::getTicks() + (500 * Time::Multiplier::Millisecond);
  while (Time::getTicks() < deadline) {
    Thread::WaitDebugInfo info = {};
    uintptr_t address = 0;
    if (thread->getWaitDebugInfo(info) && info.queue && info.queued &&
        thread->getDebugState(address) == Thread::CondWait) {
      admissionWait = address == location;
      return true;
    }
    if (controller.readRequestCount() > priorReadCount) {
      admissionWait = false;
      return true;
    }
    Scheduler::instance().yield();
  }
  admissionWait = false;
  return false;
}
 
bool waitForRetireAdmissionOrDrain(Thread* retirer, HostedScsiDisk& disk, uint64_t location,
                                   bool& admissionWait) {
  const Time::Timestamp deadline = Time::getTicks() + (500 * Time::Multiplier::Millisecond);
  while (Time::getTicks() < deadline) {
    Thread::WaitDebugInfo info = {};
    uintptr_t address = 0;
    if (retirer->getWaitDebugInfo(info) && info.queue && info.queued &&
        retirer->getDebugState(address) == Thread::CondWait && address == location) {
      admissionWait = true;
      return true;
    }
    if (!disk.pageAddress(location)) {
      admissionWait = false;
      return true;
    }
    Scheduler::instance().yield();
  }
  admissionWait = false;
  return false;
}
 
struct ReadContext {
  ReadContext(HostedScsiDisk* pDisk, uint64_t readLocation)
      : disk(pDisk), location(readLocation), returned(0), result(0) {}
 
  HostedScsiDisk* disk;
  uint64_t location;
  Atomic<size_t> returned;
  bool result;
};
 
int readPage(void* parameter) {
  auto* context = reinterpret_cast<ReadContext*>(parameter);
  const BufferView result = context->disk->read(context->location);
  context->result = static_cast<bool>(result);
  if (result)
    context->disk->unpin(context->location);
  context->returned += 1;
  return 0;
}
 
Thread* startRead(ReadContext& context, const char* name) {
  Thread* thread = new Thread(Scheduler::instance().getKernelProcess(), readPage, &context, nullptr,
                              false, true);
  thread->setName(String(name));
  return thread;
}
 
struct ReadRequestPause {
  ReadRequestPause(HostedScsiDisk* pDisk, uint64_t pageLocation)
      : disk(pDisk), location(pageLocation), state(0), entered(0, false), release(0, false) {}
 
  void arm() {
    const size_t staleEntries = entered.drainAvailable();
    const size_t staleReleases = release.drainAvailable();
    (void)staleEntries;
    (void)staleReleases;
    state = 1;
    ScsiDisk::setHostedReadRequestHookForTest(pause, this);
  }
 
  bool wait() {
    return entered.acquireForCompletion(1, 0, 500000);
  }
 
  void resume() {
    release.release();
  }
 
  void clear() {
    ScsiDisk::setHostedReadRequestHookForTest(nullptr, nullptr);
    state = 0;
  }
 
  static void pause(ScsiDisk* pDisk, uint64_t pageLocation, void* parameter) {
    auto* context = reinterpret_cast<ReadRequestPause*>(parameter);
    if (!context || pDisk != context->disk || pageLocation != context->location ||
        !context->state.compareAndSwap(1, 2)) {
      return;
    }
 
    context->entered.release();
    if (!context->release.acquireForCompletion())
      context->state = 0;
    context->state = 0;
  }
 
  HostedScsiDisk* disk;
  uint64_t location;
  Atomic<size_t> state;
  Semaphore entered;
  Semaphore release;
};
 
struct AtaRetirementContext {
  AtaRetirementContext(HostedScsiDisk* pDisk, uint64_t pageLocation, uintptr_t pageBuffer)
      : disk(pDisk),
        location(pageLocation),
        page(pageBuffer),
        callbacks(0),
        argumentsValid(0),
        returned(0),
        succeeded(0) {}
 
  HostedScsiDisk* disk;
  uint64_t location;
  uintptr_t page;
  Atomic<size_t> callbacks;
  Atomic<size_t> argumentsValid;
  Atomic<size_t> returned;
  Atomic<size_t> succeeded;
};
 
bool retireAtaPageCallback(uintptr_t key, uintptr_t page, void* parameter) {
  auto* context = reinterpret_cast<AtaRetirementContext*>(parameter);
  context->callbacks += 1;
  context->argumentsValid = key == context->location && page == context->page;
  return true;
}
 
int retireAtaPage(void* parameter) {
  auto* context = reinterpret_cast<AtaRetirementContext*>(parameter);
  if (context->disk->retirePage(context->location, retireAtaPageCallback, context))
    context->succeeded += 1;
  context->returned += 1;
  return 0;
}
 
bool ataDrainingMissReleasesQueuedPin(Fixture& fixture) {
  const bool prepared = fixture.ready && fixture.disk.preparePage(AtaDrainingLocation);
  const uintptr_t page = prepared ? fixture.disk.pageAddress(AtaDrainingLocation) : 0;
  const bool pinned = page && fixture.disk.pin(AtaDrainingLocation);
 
  AtaRetirementContext context(&fixture.disk, AtaDrainingLocation, page);
  Thread* retirer = nullptr;
  if (pinned) {
    retirer = new Thread(Scheduler::instance().getKernelProcess(), retireAtaPage, &context, nullptr,
                         false, true);
    retirer->setName("hosted ATA queued-write page retirer");
  }
 
  const bool drainPublished =
      retirer && waitUntilQueuedAt(retirer, Thread::CallbackDrain, AtaDrainingLocation);
  const bool missed = drainPublished && fixture.disk.missesAtaQueuedWritePage(AtaDrainingLocation);
  const bool completedWithoutRepair = missed && waitUntilSet(context.returned);
  bool repaired = false;
  if (pinned && !static_cast<size_t>(context.returned)) {
    fixture.disk.unpin(AtaDrainingLocation);
    repaired = true;
  }
  const bool completed =
      retirer && (static_cast<size_t>(context.returned) || waitUntilSet(context.returned));
  const bool joined = retirer && retirer->joinForCompletion();
  const bool retired = completed && joined && context.succeeded == 1 && context.callbacks == 1 &&
                       context.argumentsValid == 1 && !fixture.disk.hasPage(AtaDrainingLocation);
  return prepared && page && pinned && drainPublished && missed && completedWithoutRepair &&
         !repaired && retired;
}
 
bool ataQueuedWriteCacheOwnership(Fixture& fixture) {
  const bool prepared = fixture.ready && fixture.disk.preparePage(AtaOwnershipLocation);
  const bool pinned = prepared && fixture.disk.pin(AtaOwnershipLocation);
  const bool acquired = pinned && fixture.disk.takeAtaQueuedWritePage(AtaOwnershipLocation);
  const RetirementResult retired = prepared
                                       ? retireAndRepair(fixture.disk, AtaOwnershipLocation, pinned)
                                       : RetirementResult{false, true};
  const bool drainingMiss = retired.cleaned && ataDrainingMissReleasesQueuedPin(fixture);
  const bool passed =
      prepared && pinned && acquired && retired.balanced && retired.cleaned && drainingMiss;
  if (passed) {
    NOTICE("HOSTED-WAIT-TEST: PASS ata-queued-write-cache-ownership");
  } else {
    ERROR(
        "HOSTED-WAIT-TEST: FAIL ata-queued-write-cache-ownership: queued pin was not traded "
        "for one bounded execution pin");
  }
  return passed;
}
 
struct ScsiWriteCaseResult {
  uint64_t result;
  bool trace;
  bool balanced;
  bool cleaned;
};
 
ScsiWriteCaseResult runScsiWriteCase(Fixture& fixture, uint64_t location, WriteMode mode,
                                     const uint8_t* expectedOpcodes, size_t expectedCount) {
  const bool prepared = fixture.ready && fixture.disk.preparePage(location);
  fixture.controller.beginWrites(mode);
  const bool pinned = prepared && fixture.disk.pin(location);
  const uint64_t result =
      pinned ? fixture.controller.addRequest(0, SCSI_REQUEST_WRITE,
                                             reinterpret_cast<uint64_t>(&fixture.disk), location)
             : 0;
  const bool trace = pinned && fixture.controller.writeTraceMatches(expectedOpcodes, expectedCount);
  const RetirementResult retired =
      prepared ? retireAndRepair(fixture.disk, location, pinned) : RetirementResult{false, true};
  return {result, trace, retired.balanced, retired.cleaned};
}
 
bool scsiWriteResult(Fixture& fixture) {
  constexpr uint8_t FailedOpcodes[] = {0x2a, 0x2a, 0x2a, 0xaa, 0xaa, 0xaa, 0x8a, 0x8a, 0x8a};
  constexpr uint8_t SuccessfulOpcodes[] = {0x2a, 0x2a, 0x2a, 0xaa};
 
  const ScsiWriteCaseResult failed = runScsiWriteCase(
      fixture, FailedWriteLocation, WriteMode::FailAll, FailedOpcodes, sizeof(FailedOpcodes));
  const ScsiWriteCaseResult successful =
      runScsiWriteCase(fixture, SuccessfulWriteLocation, WriteMode::PassWrite12, SuccessfulOpcodes,
                       sizeof(SuccessfulOpcodes));
  const bool passed = !failed.result && failed.trace && failed.balanced && failed.cleaned &&
                      successful.result == PageBytes && successful.trace && successful.balanced &&
                      successful.cleaned;
  if (passed) {
    NOTICE("HOSTED-WAIT-TEST: PASS scsi-write-result");
  } else {
    ERROR(
        "HOSTED-WAIT-TEST: FAIL scsi-write-result: all-command failure was reported as success "
        "or fallback/ownership changed");
  }
  return passed;
}
 
struct DirectRetirementContext {
  DirectRetirementContext(HostedScsiDisk* pDisk, uint64_t pageLocation)
      : disk(pDisk), location(pageLocation), returned(0), succeeded(0) {}
 
  HostedScsiDisk* disk;
  uint64_t location;
  Atomic<size_t> returned;
  Atomic<size_t> succeeded;
};
 
int retireDirectPage(void* parameter) {
  auto* context = reinterpret_cast<DirectRetirementContext*>(parameter);
  if (context->disk->retireCachePage(context->location))
    context->succeeded += 1;
  context->returned += 1;
  return 0;
}
 
bool scsiDirectRetireResult(Fixture& fixture) {
  constexpr uint8_t FailedOpcodes[] = {0x2a, 0x2a, 0x2a, 0xaa, 0xaa, 0xaa, 0x8a, 0x8a, 0x8a};
  constexpr uint8_t SuccessfulOpcodes[] = {0x2a, 0x2a, 0x2a, 0xaa};
 
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  const bool missing = fixture.ready && fixture.disk.retireCachePage(MissingDirectLocation) &&
                       fixture.controller.hasNoDirectActivity();
 
  const bool editingPrepared = fixture.disk.prepareEditingPage(EditingDirectLocation);
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  const bool editingRejected = editingPrepared &&
                               !fixture.disk.retireCachePage(EditingDirectLocation) &&
                               fixture.controller.hasNoDirectActivity();
  const bool editingDiscarded =
      editingPrepared && fixture.disk.discardEditingPage(EditingDirectLocation);
 
  const bool successfulPrepared = fixture.disk.preparePage(SuccessfulDirectLocation);
  const uintptr_t successfulPage =
      successfulPrepared ? fixture.disk.pageAddress(SuccessfulDirectLocation) : 0;
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  fixture.disk.beginUnpinObservation();
  const bool successfulRetired =
      successfulPage && fixture.disk.retireCachePage(SuccessfulDirectLocation);
  const size_t successfulUnpins = fixture.disk.endUnpinObservation();
  const bool successfulTrace =
      fixture.controller.writeTraceMatches(SuccessfulOpcodes, sizeof(SuccessfulOpcodes));
  const bool successfulTuple = fixture.controller.directTupleMatches(
      &fixture.disk, SuccessfulDirectLocation, successfulPage);
  const bool successful = successfulPrepared && successfulRetired && successfulTrace &&
                          successfulTuple && fixture.controller.unitReadyCount() == 1 &&
                          fixture.controller.lastWriteBuffer() == successfulPage &&
                          successfulUnpins == 0 && !fixture.disk.hasPage(SuccessfulDirectLocation);
 
  const bool canonicalPrepared = fixture.disk.preparePage(CanonicalDirectLocation);
  const uintptr_t canonicalPage =
      canonicalPrepared ? fixture.disk.pageAddress(CanonicalDirectLocation) : 0;
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  const bool canonicalRetired = canonicalPage &&
                                fixture.disk.retireCachePage(CanonicalDirectLocation + 512) &&
                                fixture.controller.directTupleMatches(
                                    &fixture.disk, CanonicalDirectLocation, canonicalPage) &&
                                fixture.controller.lastWriteBuffer() == canonicalPage &&
                                !fixture.disk.hasPage(CanonicalDirectLocation);
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  const bool endRejected = !fixture.disk.retireCachePage(fixture.disk.getSize()) &&
                           fixture.controller.hasNoDirectActivity();
 
  const bool failedPrepared = fixture.disk.preparePage(FailedDirectLocation);
  const uintptr_t failedPage = failedPrepared ? fixture.disk.pageAddress(FailedDirectLocation) : 0;
  fixture.controller.beginWrites(WriteMode::FailAll);
  const bool failedRetirement = failedPage && !fixture.disk.retireCachePage(FailedDirectLocation);
  const bool failedTrace =
      fixture.controller.writeTraceMatches(FailedOpcodes, sizeof(FailedOpcodes));
  const bool failedTuple =
      fixture.controller.directTupleMatches(&fixture.disk, FailedDirectLocation, failedPage);
  const bool failedRetained = failedRetirement && fixture.disk.hasPage(FailedDirectLocation);
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  const bool failedRetry =
      failedRetained && fixture.disk.retireCachePage(FailedDirectLocation) &&
      fixture.controller.writeTraceMatches(SuccessfulOpcodes, sizeof(SuccessfulOpcodes)) &&
      !fixture.disk.hasPage(FailedDirectLocation);
 
  const bool unreadyPrepared = fixture.disk.preparePage(UnreadyDirectLocation);
  const uintptr_t unreadyPage =
      unreadyPrepared ? fixture.disk.pageAddress(UnreadyDirectLocation) : 0;
  fixture.controller.beginWrites(WriteMode::UnitNotReady);
  const bool unreadyRetirement =
      unreadyPage && !fixture.disk.retireCachePage(UnreadyDirectLocation);
  const bool unready =
      unreadyRetirement &&
      fixture.controller.directTupleMatches(&fixture.disk, UnreadyDirectLocation, unreadyPage) &&
      fixture.controller.unitReadyCount() == 3 && fixture.controller.writeCount() == 0 &&
      fixture.disk.hasPage(UnreadyDirectLocation);
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  const bool unreadyRetry = unready && fixture.disk.retireCachePage(UnreadyDirectLocation) &&
                            !fixture.disk.hasPage(UnreadyDirectLocation);
 
  const bool shortPrepared = fixture.disk.preparePage(ShortDirectLocation);
  const uintptr_t shortPage = shortPrepared ? fixture.disk.pageAddress(ShortDirectLocation) : 0;
  fixture.disk.overrideDirectResult(1);
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  const bool shortRetirement = shortPage && !fixture.disk.retireCachePage(ShortDirectLocation);
  const bool shortResultRejected =
      shortRetirement &&
      fixture.controller.directTupleMatches(&fixture.disk, ShortDirectLocation, shortPage) &&
      fixture.controller.unitReadyCount() == 0 && fixture.controller.writeCount() == 0 &&
      fixture.disk.hasPage(ShortDirectLocation);
  fixture.disk.restoreDirectResult();
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  const bool shortRetry = shortResultRejected &&
                          fixture.disk.retireCachePage(ShortDirectLocation) &&
                          !fixture.disk.hasPage(ShortDirectLocation);
 
  const bool passed = missing && editingRejected && editingDiscarded && successful &&
                      canonicalPrepared && canonicalRetired && endRejected && failedRetained &&
                      failedTrace && failedTuple && failedRetry && unreadyPrepared &&
                      unreadyRetry && shortPrepared && shortRetry;
  if (passed) {
    NOTICE("HOSTED-WAIT-TEST: PASS scsi-direct-retire-result");
  } else {
    ERROR(
        "HOSTED-WAIT-TEST: FAIL scsi-direct-retire-result: DIRECT routing, exact result, "
        "retry, or supplied-page write semantics changed");
  }
  return passed;
}
 
bool scsiDirectRetireOwnership(Fixture& fixture) {
  constexpr uint8_t SuccessfulOpcodes[] = {0x2a, 0x2a, 0x2a, 0xaa};
 
  const bool pinnedPrepared = fixture.disk.preparePage(PinnedDirectLocation);
  const uintptr_t pinnedPage = pinnedPrepared ? fixture.disk.pageAddress(PinnedDirectLocation) : 0;
  const bool pinned = pinnedPage && fixture.disk.pin(PinnedDirectLocation);
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  DirectRetirementContext context(&fixture.disk, PinnedDirectLocation);
  Thread* retirer = nullptr;
  if (pinned) {
    retirer = new Thread(Scheduler::instance().getKernelProcess(), retireDirectPage, &context,
                         nullptr, false, true);
    retirer->setName("hosted SCSI direct-page retirer");
  }
 
  const bool drainPublished =
      retirer && waitUntilQueuedAt(retirer, Thread::CallbackDrain, PinnedDirectLocation);
  const bool blockedWithoutIo = drainPublished && !static_cast<size_t>(context.returned) &&
                                fixture.controller.hasNoDirectActivity();
  if (pinned)
    fixture.disk.unpin(PinnedDirectLocation);
  const bool completed =
      retirer && (static_cast<size_t>(context.returned) || waitUntilSet(context.returned));
  const bool joined = retirer && retirer->joinForCompletion();
  const bool pinnedRetired =
      completed && joined && context.succeeded == 1 &&
      fixture.controller.directTupleMatches(&fixture.disk, PinnedDirectLocation, pinnedPage) &&
      fixture.controller.writeTraceMatches(SuccessfulOpcodes, sizeof(SuccessfulOpcodes)) &&
      fixture.controller.lastWriteBuffer() == pinnedPage &&
      !fixture.disk.hasPage(PinnedDirectLocation);
 
  const bool cancelledPrepared = fixture.disk.preparePage(CancelledDirectLocation);
  const uintptr_t cancelledPage =
      cancelledPrepared ? fixture.disk.pageAddress(CancelledDirectLocation) : 0;
  const bool halted = cancelledPage && fixture.controller.halt();
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  fixture.disk.beginUnpinObservation();
  const bool cancelled = halted && !fixture.disk.retireCachePage(CancelledDirectLocation);
  const size_t cancelledUnpins = fixture.disk.endUnpinObservation();
  const uint64_t cancelledUnpinLocation = fixture.disk.lastUnpinLocation();
  const bool cancellationPreserved = cancelled && fixture.controller.hasNoDirectActivity() &&
                                     cancelledUnpins == 0 && cancelledUnpinLocation == 0 &&
                                     fixture.disk.hasPage(CancelledDirectLocation);
  const bool resumed = halted && fixture.controller.resume();
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  const bool cancellationRetry = cancellationPreserved && resumed &&
                                 fixture.disk.retireCachePage(CancelledDirectLocation) &&
                                 fixture.controller.directTupleMatches(
                                     &fixture.disk, CancelledDirectLocation, cancelledPage) &&
                                 fixture.controller.lastWriteBuffer() == cancelledPage &&
                                 !fixture.disk.hasPage(CancelledDirectLocation);
 
  const bool passed = pinnedPrepared && pinned && drainPublished && blockedWithoutIo &&
                      pinnedRetired && cancelledPrepared && cancellationRetry;
  if (passed) {
    NOTICE("HOSTED-WAIT-TEST: PASS scsi-direct-retire-ownership");
  } else {
    ERROR(
        "HOSTED-WAIT-TEST: FAIL scsi-direct-retire-ownership: borrowed DIRECT pages were "
        "used before drain or released by execution/cancellation");
  }
  return passed;
}
 
bool scsiReadRetireAdmission(Fixture& fixture) {
  constexpr RequestEvent ExpectedOrder[] = {RequestEvent::Read, RequestEvent::Direct,
                                            RequestEvent::Read};
 
  fixture.disk.setCacheFillSize(PageBytes);
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  fixture.controller.beginRequestTrace();
  fixture.controller.holdNextRead();
 
  ReadContext firstRead(&fixture.disk, ReadFirstLocation);
  Thread* firstReader = startRead(firstRead, "hosted SCSI admitted first reader");
  const bool firstReadEntered = firstReader && fixture.controller.waitForHeldRead();
  const bool prepared = firstReadEntered && fixture.disk.preparePage(ReadFirstLocation);
  const bool retireSerialPin = prepared && fixture.disk.pin(ReadFirstLocation);
 
  DirectRetirementContext retirement(&fixture.disk, ReadFirstLocation);
  Thread* retirer = nullptr;
  if (retireSerialPin) {
    retirer = new Thread(Scheduler::instance().getKernelProcess(), retireDirectPage, &retirement,
                         nullptr, false, true);
    retirer->setName("hosted SCSI queued-read retirement");
  }
 
  bool retireAdmissionWait = false;
  const bool retireStopped =
      retirer &&
      waitForRetireAdmissionOrDrain(retirer, fixture.disk, ReadFirstLocation, retireAdmissionWait);
  const bool retireIntentQueued = retireStopped && retireAdmissionWait;
  const bool pageStayedVisible = retireIntentQueued && fixture.disk.pageAddress(ReadFirstLocation);
 
  DirectRetirementContext secondRetirement(&fixture.disk, ReadFirstLocation);
  Thread* secondRetirer = nullptr;
  if (retirer) {
    secondRetirer = new Thread(Scheduler::instance().getKernelProcess(), retireDirectPage,
                               &secondRetirement, nullptr, false, true);
    secondRetirer->setName("hosted SCSI second queued retirement");
  }
  bool secondRetireAdmissionWait = false;
  const bool secondRetireStopped =
      secondRetirer && waitForRetireAdmissionOrDrain(secondRetirer, fixture.disk, ReadFirstLocation,
                                                     secondRetireAdmissionWait);
  const bool retiresSerialised = secondRetireStopped && secondRetireAdmissionWait;
 
  fixture.controller.holdFollowingRead();
  ReadContext secondRead(&fixture.disk, ReadFirstLocation);
  Thread* secondReader = startRead(secondRead, "hosted SCSI writer-preference reader");
  bool secondAdmissionWait = false;
  const bool secondStopped =
      secondReader && waitForAdmissionOrRead(secondReader, ReadFirstLocation, fixture.controller, 1,
                                             secondAdmissionWait);
  const bool writerPreferred = secondStopped && secondAdmissionWait;
  const bool safeToDelegate =
      retireIntentQueued && pageStayedVisible && retiresSerialised && writerPreferred;
  fixture.controller.releaseHeldRead(safeToDelegate);
 
  const bool firstCompleted =
      firstReader && (static_cast<size_t>(firstRead.returned) || waitUntilSet(firstRead.returned));
  bool secondReadEntered = false;
  if (!writerPreferred) {
    secondReadEntered = fixture.controller.waitForHeldRead();
    fixture.controller.releaseHeldRead(false);
  }
  const bool firstRetireDraining =
      safeToDelegate && firstCompleted &&
      waitUntilQueuedAt(retirer, Thread::CallbackDrain, ReadFirstLocation);
  const bool secondRetireStillQueued =
      firstRetireDraining && waitUntilQueuedAt(secondRetirer, Thread::CondWait, ReadFirstLocation);
  if (retireSerialPin)
    fixture.disk.unpin(ReadFirstLocation);
  const bool retireCompleted =
      retirer && (static_cast<size_t>(retirement.returned) || waitUntilSet(retirement.returned));
  const bool secondRetireCompleted =
      secondRetirer &&
      (static_cast<size_t>(secondRetirement.returned) || waitUntilSet(secondRetirement.returned));
  if (secondReader && writerPreferred) {
    secondReadEntered = fixture.controller.waitForHeldRead();
    fixture.controller.releaseHeldRead(true);
  }
  const bool secondCompleted = secondReader && (static_cast<size_t>(secondRead.returned) ||
                                                waitUntilSet(secondRead.returned));
  const bool firstJoined = firstReader && firstReader->joinForCompletion();
  const bool retireJoined = retirer && retirer->joinForCompletion();
  const bool secondRetireJoined = secondRetirer && secondRetirer->joinForCompletion();
  const bool secondJoined = secondReader && secondReader->joinForCompletion();
 
  const bool ordered = fixture.controller.requestTraceMatches(
      ExpectedOrder, sizeof(ExpectedOrder) / sizeof(ExpectedOrder[0]));
  const bool queueCycleClosed =
      firstCompleted && firstRetireDraining && secondRetireStillQueued && retireCompleted &&
      secondRetireCompleted && secondCompleted && firstJoined && retireJoined &&
      secondRetireJoined && secondJoined && secondReadEntered && firstRead.result &&
      retirement.succeeded == 1 && secondRetirement.succeeded == 1 && secondRead.result &&
      ordered && fixture.controller.readCommandCount() == 1 &&
      fixture.controller.directRequestCount() == 1 && fixture.disk.hasPage(ReadFirstLocation);
 
  const bool halted = fixture.controller.halt();
  const bool rejectedRead = halted && static_cast<bool>(fixture.disk.read(RejectedReadLocation));
  DirectRetirementContext rejectedRetirement(&fixture.disk, RejectedReadLocation);
  Thread* rejectedRetirer = nullptr;
  if (halted && !rejectedRead) {
    rejectedRetirer = new Thread(Scheduler::instance().getKernelProcess(), retireDirectPage,
                                 &rejectedRetirement, nullptr, false, true);
    rejectedRetirer->setName("hosted SCSI rejected-read retirement");
  }
  const bool rejectedCompleted =
      rejectedRetirer && (static_cast<size_t>(rejectedRetirement.returned) ||
                          waitUntilSet(rejectedRetirement.returned));
  const bool rejectedJoined = rejectedRetirer && rejectedRetirer->joinForCompletion();
  const bool resumed = halted && fixture.controller.resume();
  const bool rejectionReleased =
      !rejectedRead && rejectedCompleted && rejectedJoined && rejectedRetirement.succeeded == 1;
 
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  const bool cleaned = fixture.disk.retireCachePage(ReadFirstLocation);
  const bool passed = fixture.ready && prepared && retireSerialPin && firstReadEntered &&
                      retireIntentQueued && pageStayedVisible && retiresSerialised &&
                      writerPreferred && queueCycleClosed && halted && resumed &&
                      rejectionReleased && cleaned;
  if (passed) {
    NOTICE("HOSTED-WAIT-TEST: PASS scsi-read-retire-admission");
  } else {
    ERROR(
        "HOSTED-WAIT-TEST: FAIL scsi-read-retire-admission: queued reads, retirement intent, "
        "writer preference, or rejected-request cleanup changed");
  }
  return passed;
}
 
bool retireCachedRange(Fixture& fixture, uint64_t location, size_t length) {
  bool retired = true;
  for (size_t offset = 0; offset < length; offset += PageBytes) {
    if (!fixture.disk.hasPage(location + offset))
      continue;
    fixture.controller.beginWrites(WriteMode::PassWrite12);
    if (!fixture.disk.retireCachePage(location + offset))
      retired = false;
  }
  return retired;
}
 
bool scsiRetireReadRecheck(Fixture& fixture) {
  constexpr size_t WideFill = PageBytes * 2;
  constexpr RequestEvent RangeOrder[] = {RequestEvent::Read, RequestEvent::Direct,
                                         RequestEvent::Read};
  constexpr RequestEvent FailedRetirementOrder[] = {RequestEvent::Direct};
 
  fixture.disk.setCacheFillSize(WideFill);
  const bool interiorPrepared = fixture.disk.preparePage(RetireFirstInterior);
  const bool interiorPinned = interiorPrepared && fixture.disk.pin(RetireFirstInterior);
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  fixture.controller.beginRequestTrace();
 
  DirectRetirementContext rangeRetirement(&fixture.disk, RetireFirstInterior);
  Thread* rangeRetirer = nullptr;
  if (interiorPinned) {
    rangeRetirer = new Thread(Scheduler::instance().getKernelProcess(), retireDirectPage,
                              &rangeRetirement, nullptr, false, true);
    rangeRetirer->setName("hosted SCSI interior-page retirer");
  }
  const bool rangeDrainPublished =
      rangeRetirer && waitUntilQueuedAt(rangeRetirer, Thread::CallbackDrain, RetireFirstInterior);
 
  ReadContext nonoverlapRead(&fixture.disk, NonoverlapReadLocation);
  Thread* nonoverlapReader = startRead(nonoverlapRead, "hosted SCSI disjoint retirement reader");
  bool nonoverlapCompleted = nonoverlapReader && (static_cast<size_t>(nonoverlapRead.returned) ||
                                                  waitUntilSet(nonoverlapRead.returned));
  bool releasedForRepair = false;
  if (interiorPinned && !nonoverlapCompleted) {
    fixture.disk.unpin(RetireFirstInterior);
    releasedForRepair = true;
    nonoverlapCompleted = waitUntilSet(nonoverlapRead.returned);
  }
  const bool nonoverlapJoined = nonoverlapReader && nonoverlapReader->joinForCompletion();
  const bool disjointProgress =
      nonoverlapCompleted && nonoverlapJoined && nonoverlapRead.result && !releasedForRepair;
 
  bool overlapAdmissionWait = false;
  bool overlapStopped = false;
  bool overlapReadEntered = false;
  bool overlapCompleted = false;
  bool overlapJoined = false;
  ReadContext overlapRead(&fixture.disk, RetireFirstExtent);
  Thread* overlapReader = nullptr;
  if (disjointProgress) {
    fixture.controller.holdNextRead();
    overlapReader = startRead(overlapRead, "hosted SCSI interior-overlap reader");
    overlapStopped =
        overlapReader && waitForAdmissionOrRead(overlapReader, RetireFirstExtent,
                                                fixture.controller, 1, overlapAdmissionWait);
    if (!overlapAdmissionWait) {
      overlapReadEntered = fixture.controller.waitForHeldRead();
      fixture.controller.releaseHeldRead(false);
    }
  }
 
  if (interiorPinned && !releasedForRepair)
    fixture.disk.unpin(RetireFirstInterior);
  const bool rangeRetireCompleted =
      rangeRetirer &&
      (static_cast<size_t>(rangeRetirement.returned) || waitUntilSet(rangeRetirement.returned));
  const bool rangeRetireJoined = rangeRetirer && rangeRetirer->joinForCompletion();
 
  if (overlapReader && overlapAdmissionWait) {
    overlapReadEntered = fixture.controller.waitForHeldRead();
    fixture.controller.releaseHeldRead(true);
  }
  if (overlapReader) {
    overlapCompleted =
        static_cast<size_t>(overlapRead.returned) || waitUntilSet(overlapRead.returned);
    overlapJoined = overlapReader->joinForCompletion();
  }
 
  const bool rangeOrder = fixture.controller.requestTraceMatches(
      RangeOrder, sizeof(RangeOrder) / sizeof(RangeOrder[0]));
  const bool rangeAdmission =
      rangeDrainPublished && disjointProgress && overlapStopped && overlapAdmissionWait &&
      overlapReadEntered && rangeRetireCompleted && rangeRetireJoined &&
      rangeRetirement.succeeded == 1 && overlapCompleted && overlapJoined && overlapRead.result &&
      fixture.controller.readCommandCount() == 2 && rangeOrder &&
      fixture.disk.hasPage(RetireFirstExtent) && fixture.disk.hasPage(RetireFirstInterior);
  const bool rangeCleaned = retireCachedRange(fixture, RetireFirstExtent, WideFill) &&
                            retireCachedRange(fixture, NonoverlapReadLocation, WideFill);
 
  fixture.disk.setCacheFillSize(PageBytes);
  const bool recheckPrepared = fixture.disk.preparePage(RecheckReadLocation);
  const bool recheckPinned = recheckPrepared && fixture.disk.pin(RecheckReadLocation);
  fixture.disk.overrideDirectResult(0);
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  fixture.controller.beginRequestTrace();
 
  DirectRetirementContext failedRetirement(&fixture.disk, RecheckReadLocation);
  Thread* failedRetirer = nullptr;
  if (recheckPinned) {
    failedRetirer = new Thread(Scheduler::instance().getKernelProcess(), retireDirectPage,
                               &failedRetirement, nullptr, false, true);
    failedRetirer->setName("hosted SCSI failed retirement recheck");
  }
  const bool failureDrainPublished =
      failedRetirer && waitUntilQueuedAt(failedRetirer, Thread::CallbackDrain, RecheckReadLocation);
 
  fixture.controller.holdNextRead();
  ReadContext recheckRead(&fixture.disk, RecheckReadLocation);
  Thread* recheckReader = startRead(recheckRead, "hosted SCSI reopened-page reader");
  bool recheckAdmissionWait = false;
  const bool recheckStopped =
      recheckReader && waitForAdmissionOrRead(recheckReader, RecheckReadLocation,
                                              fixture.controller, 0, recheckAdmissionWait);
  bool recheckReadEntered = false;
  if (!recheckAdmissionWait) {
    recheckReadEntered = fixture.controller.waitForHeldRead();
    fixture.controller.releaseHeldRead(false);
  }
 
  if (recheckPinned)
    fixture.disk.unpin(RecheckReadLocation);
  const bool failedRetireCompleted =
      failedRetirer &&
      (static_cast<size_t>(failedRetirement.returned) || waitUntilSet(failedRetirement.returned));
  const bool failedRetireJoined = failedRetirer && failedRetirer->joinForCompletion();
  bool recheckCompleted = recheckReader && (static_cast<size_t>(recheckRead.returned) ||
                                            waitUntilSet(recheckRead.returned));
  if (!recheckCompleted) {
    recheckReadEntered = fixture.controller.waitForHeldRead();
    fixture.controller.releaseHeldRead(false);
    recheckCompleted = waitUntilSet(recheckRead.returned);
  } else if (!fixture.controller.readRequestCount()) {
    fixture.controller.disarmReadHold();
  }
  const bool recheckJoined = recheckReader && recheckReader->joinForCompletion();
  const bool failedOrder = fixture.controller.requestTraceMatches(
      FailedRetirementOrder, sizeof(FailedRetirementOrder) / sizeof(FailedRetirementOrder[0]));
  const bool failureRechecked = failureDrainPublished && recheckStopped && recheckAdmissionWait &&
                                !recheckReadEntered && failedRetireCompleted &&
                                failedRetireJoined && failedRetirement.succeeded == 0 &&
                                recheckCompleted && recheckJoined && recheckRead.result &&
                                fixture.controller.readRequestCount() == 0 && failedOrder &&
                                fixture.disk.hasPage(RecheckReadLocation);
 
  fixture.disk.restoreDirectResult();
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  const bool recheckCleaned = fixture.disk.retireCachePage(RecheckReadLocation);
 
  constexpr RequestEvent LookupPauseOrder[] = {RequestEvent::Read, RequestEvent::Direct};
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  fixture.controller.beginRequestTrace();
  ReadRequestPause lookupPause(&fixture.disk, LookupPauseLocation);
  lookupPause.arm();
 
  ReadContext pausedRead(&fixture.disk, LookupPauseLocation);
  Thread* pausedReader = startRead(pausedRead, "hosted SCSI pre-lookup reader");
  const bool lookupPauseEntered = pausedReader && lookupPause.wait();
  const bool readPublished = lookupPauseEntered && fixture.disk.hasPage(LookupPauseLocation);
 
  ReadContext sharedRead(&fixture.disk, LookupPauseLocation);
  Thread* sharedReader = nullptr;
  if (readPublished) {
    sharedReader = startRead(sharedRead, "hosted SCSI shared cache-hit reader");
  }
  // The first reader owns exclusive admission through publication and lookup.
  // An overlapping reader must queue ahead of retirement, then reuse its page.
  const bool sharedBlockedBeforeRelease =
      sharedReader && waitUntilQueuedAt(sharedReader, Thread::CondWait, LookupPauseLocation) &&
      !static_cast<size_t>(sharedRead.returned);
 
  DirectRetirementContext lookupRetirement(&fixture.disk, LookupPauseLocation);
  Thread* lookupRetirer = nullptr;
  if (sharedReader) {
    lookupRetirer = new Thread(Scheduler::instance().getKernelProcess(), retireDirectPage,
                               &lookupRetirement, nullptr, false, true);
    lookupRetirer->setName("hosted SCSI pre-lookup retirer");
  }
  bool lookupRetireAdmissionWait = false;
  const bool lookupRetireStopped =
      lookupRetirer &&
      waitForRetireAdmissionOrDrain(lookupRetirer, fixture.disk, LookupPauseLocation,
                                    lookupRetireAdmissionWait);
  const bool admissionHeldThroughLookup = lookupRetireStopped && lookupRetireAdmissionWait &&
                                          fixture.disk.pageAddress(LookupPauseLocation);
 
  lookupPause.resume();
  const bool pausedCompleted = pausedReader && (static_cast<size_t>(pausedRead.returned) ||
                                                waitUntilSet(pausedRead.returned));
  const bool sharedCompleted = sharedReader && (static_cast<size_t>(sharedRead.returned) ||
                                                waitUntilSet(sharedRead.returned));
  const bool lookupRetireCompleted =
      lookupRetirer &&
      (static_cast<size_t>(lookupRetirement.returned) || waitUntilSet(lookupRetirement.returned));
  const bool pausedJoined = pausedReader && pausedReader->joinForCompletion();
  const bool sharedJoined = sharedReader && sharedReader->joinForCompletion();
  const bool lookupRetireJoined = lookupRetirer && lookupRetirer->joinForCompletion();
  lookupPause.clear();
 
  const bool lookupOrder = fixture.controller.requestTraceMatches(
      LookupPauseOrder, sizeof(LookupPauseOrder) / sizeof(LookupPauseOrder[0]));
  const bool finalLookupProtected =
      lookupPauseEntered && readPublished && sharedBlockedBeforeRelease &&
      admissionHeldThroughLookup && pausedCompleted && sharedCompleted && lookupRetireCompleted &&
      pausedJoined && sharedJoined && lookupRetireJoined && pausedRead.result &&
      sharedRead.result && lookupRetirement.succeeded == 1 &&
      fixture.controller.readRequestCount() == 1 && fixture.controller.readCommandCount() == 1 &&
      fixture.controller.directRequestCount() == 1 && lookupOrder;
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  const bool lookupCleaned = !fixture.disk.hasPage(LookupPauseLocation) ||
                             fixture.disk.retireCachePage(LookupPauseLocation);
 
  const bool passed = interiorPrepared && interiorPinned && rangeAdmission && rangeCleaned &&
                      recheckPrepared && recheckPinned && failureRechecked && recheckCleaned &&
                      finalLookupProtected && lookupCleaned;
  if (passed) {
    NOTICE("HOSTED-WAIT-TEST: PASS scsi-retire-read-recheck");
  } else {
    ERROR("HOSTED-WAIT-TEST: FAIL scsi-retire-read-recheck");
    ERROR("SCSI recheck range: prepared=" << interiorPrepared << ", pinned=" << interiorPinned
                                          << ", admission=" << rangeAdmission
                                          << ", cleanup=" << rangeCleaned);
    ERROR("SCSI recheck failure: prepared=" << recheckPrepared << ", pinned=" << recheckPinned
                                            << ", rechecked=" << failureRechecked
                                            << ", cleanup=" << recheckCleaned);
    ERROR("SCSI recheck lookup: pause=" << lookupPauseEntered << ", published=" << readPublished
                                        << ", reader-wait=" << sharedBlockedBeforeRelease
                                        << ", retire-wait=" << admissionHeldThroughLookup);
    ERROR("SCSI recheck result: lookup=" << finalLookupProtected << ", cleanup=" << lookupCleaned);
  }
  return passed;
}
 
bool scsiDeferredWrites() {
  Fixture fixture;
  if (!fixture.ready || !fixture.disk.preparePage(CheckedSyncLocation))
    return false;
  fixture.disk.checksumPage(CheckedSyncLocation);
  if (!fixture.disk.runBackgroundWriteback())
    return false;
  fixture.disk.pauseBackgroundWriteback();
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  fixture.controller.beginSync(SyncMode::Pass10);
  const bool pinned = fixture.disk.pin(CheckedSyncLocation);
  for (size_t i = 0; i < 128; ++i)
    fixture.disk.write(CheckedSyncLocation);
  const bool deferred = fixture.controller.drain() && fixture.controller.hasNoDirectActivity();
  fixture.disk.resumeBackgroundWriteback();
  const bool written =
      fixture.disk.runBackgroundWriteback() && fixture.controller.directRequestCount() == 1;
  constexpr uint8_t Flush[] = {0x35};
  const bool durable = fixture.controller.syncTraceMatches(Flush, sizeof(Flush));
  const bool settled =
      fixture.disk.runBackgroundWriteback() && fixture.controller.directRequestCount() == 1;
  const bool callerPinRetained = pinned && !fixture.disk.evictPage(CheckedSyncLocation);
  if (pinned)
    fixture.disk.unpin(CheckedSyncLocation);
  const bool balanced = fixture.disk.evictPage(CheckedSyncLocation);
  const bool passed = deferred && written && durable && settled && callerPinRetained && balanced;
  if (passed)
    NOTICE("HOSTED-WAIT-TEST: PASS scsi-deferred-writes");
  else
    ERROR("HOSTED-WAIT-TEST: FAIL scsi-deferred-writes: coalescing, settling, durability or pins");
  return passed;
}
 
bool scsiScopedDiskViews() {
  Fixture fixture;
  if (!fixture.ready || !fixture.disk.preparePage(CheckedSyncLocation))
    return false;
  fixture.disk.pauseBackgroundWriteback();
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  fixture.controller.beginSync(SyncMode::Pass10);
 
  auto reader = fixture.disk.readView(CheckedSyncLocation);
  auto writer = fixture.disk.writeView(CheckedSyncLocation);
  const BufferView legacy = fixture.disk.read(CheckedSyncLocation);
  const bool pinned = fixture.disk.pin(CheckedSyncLocation);
  const bool admitted = reader && writer && legacy && pinned;
  const bool endpointHeld = admitted && !fixture.disk.tryCloseEndpoint();
  const uint32_t value = 0x12345678;
  const bool changed = writer && writer.writeAt(value, 1);
  auto moved = pedigree_std::move(writer);
  const bool transferred = !writer && moved;
  moved.reset();
  if (legacy)
    fixture.disk.unpin(CheckedSyncLocation);
  if (legacy && pinned)
    static_cast<uint8_t*>(legacy.data())[7] = 0xc7;
  if (pinned)
    fixture.disk.unpin(CheckedSyncLocation);
 
  uint32_t observed = 0;
  uint8_t last = 0;
  const bool coherent = reader && reader.readAt(observed, 1) && observed == value &&
                        reader.readAt(last, 7) && last == 0xc7;
  fixture.disk.resumeBackgroundWriteback();
  const bool written =
      fixture.disk.runBackgroundWriteback() && fixture.controller.directRequestCount() == 1;
  const bool settled =
      fixture.disk.runBackgroundWriteback() && fixture.controller.directRequestCount() == 1;
  reader.reset();
  const bool closed = fixture.disk.tryCloseEndpoint();
  fixture.disk.reopenEndpoint();
  const bool balanced =
      fixture.disk.hasNoCacheLoans() && fixture.disk.evictPage(CheckedSyncLocation);
  const bool passed = admitted && endpointHeld && changed && transferred && coherent && written &&
                      settled && closed && balanced;
  if (passed)
    NOTICE("HOSTED-WAIT-TEST: PASS scsi-scoped-disk-views");
  else
    ERROR("HOSTED-WAIT-TEST: FAIL scsi-scoped-disk-views: admission="
          << admitted << ", endpoint=" << endpointHeld << ", coherent=" << coherent
          << ", written=" << written << ", settled=" << settled << ", balanced=" << balanced);
  return passed;
}
 
bool scsiViewSurvivesAlignmentChange() {
  Fixture fixture;
  if (!fixture.ready || !fixture.disk.preparePage(0))
    return false;
  auto reader = fixture.disk.readView(2048);
  auto writer = fixture.disk.writeView(2048);
  const bool admitted = reader && writer;
  fixture.disk.align(1536);
  writer.reset();
  reader.reset();
  const bool balanced = fixture.disk.hasNoCacheLoans() && fixture.disk.evictPage(0);
  const bool passed = admitted && balanced;
  if (passed)
    NOTICE("HOSTED-WAIT-TEST: PASS scsi-view-alignment-change");
  else
    ERROR("HOSTED-WAIT-TEST: FAIL scsi-view-alignment-change: view released a different cache key");
  return passed;
}
 
bool scsiDeferredWriteRetry() {
  Fixture fixture;
  if (!fixture.ready || !fixture.disk.preparePage(CheckedSyncLocation))
    return false;
  fixture.disk.checksumPage(CheckedSyncLocation);
  if (!fixture.disk.runBackgroundWriteback())
    return false;
  fixture.disk.pauseBackgroundWriteback();
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  fixture.controller.beginSync(SyncMode::FailAll);
  fixture.disk.write(CheckedSyncLocation);
  const bool deferred = fixture.controller.drain() && fixture.controller.hasNoDirectActivity();
  fixture.disk.resumeBackgroundWriteback();
  constexpr uint8_t FailedFlushes[] = {0x35, 0x35, 0x35, 0x91, 0x91, 0x91};
  const bool failedFlush =
      fixture.disk.runBackgroundWriteback() && fixture.controller.directRequestCount() == 1 &&
      fixture.controller.syncTraceMatches(FailedFlushes, sizeof(FailedFlushes));
  // The failed device flush must remain retryable even though page bytes are unchanged.
  fixture.disk.pauseBackgroundWriteback();
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  fixture.controller.beginSync(SyncMode::Pass10);
  fixture.disk.resumeBackgroundWriteback();
  const bool retried =
      fixture.disk.runBackgroundWriteback() && fixture.controller.directRequestCount() == 1;
  constexpr uint8_t Flush[] = {0x35};
  const bool durable = fixture.controller.syncTraceMatches(Flush, sizeof(Flush));
  const bool cleaned = fixture.disk.evictPage(CheckedSyncLocation);
  const bool passed = deferred && failedFlush && retried && durable && cleaned;
  if (passed)
    NOTICE("HOSTED-WAIT-TEST: PASS scsi-deferred-write-retry");
  else
    ERROR(
        "HOSTED-WAIT-TEST: FAIL scsi-deferred-write-retry: failed flush lost retry or leaked pins");
  return passed;
}
 
bool scsiDeferredWriteShutdown() {
  Fixture fixture;
  if (!fixture.ready || !fixture.disk.preparePage(CheckedSyncLocation))
    return false;
  fixture.disk.checksumPage(CheckedSyncLocation);
  fixture.disk.pauseBackgroundWriteback();
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  fixture.controller.beginSync(SyncMode::Pass10);
  fixture.disk.write(CheckedSyncLocation);
  const bool deferred = fixture.controller.drain() && fixture.controller.hasNoDirectActivity();
  fixture.disk.shutdownCache();
  constexpr uint8_t Flush[] = {0x35};
  const bool passed = deferred && fixture.controller.directRequestCount() == 1 &&
                      fixture.controller.syncTraceMatches(Flush, sizeof(Flush));
  if (passed)
    NOTICE("HOSTED-WAIT-TEST: PASS scsi-deferred-write-shutdown");
  else
    ERROR("HOSTED-WAIT-TEST: FAIL scsi-deferred-write-shutdown: deferred page was not flushed");
  return passed;
}
 
bool scsiCheckedSync() {
  constexpr uint8_t SuccessfulWrites[] = {0x2a, 0x2a, 0x2a, 0xaa};
  constexpr uint8_t FailedSyncs[] = {0x35, 0x35, 0x35, 0x91, 0x91, 0x91};
  constexpr uint8_t RetriedSyncs[] = {0x35, 0x35, 0x35, 0x91};
  constexpr uint8_t CleanSyncs[] = {0x35, 0x35};
  Fixture fixture;
  if (!fixture.ready) {
    ERROR("HOSTED-WAIT-TEST: FAIL scsi-checked-sync: fixture setup");
    return false;
  }
  fixture.disk.pauseBackgroundWriteback();
  const BufferView read = fixture.disk.read(CheckedSyncLocation);
  const uintptr_t page = read.address();
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  fixture.controller.beginSync(SyncMode::Pass10);
  const bool cleanSynced = read && fixture.disk.sync(CheckedSyncLocation, false) &&
                           fixture.disk.sync(CheckedSyncLocation, false) &&
                           fixture.controller.hasNoDirectActivity() &&
                           fixture.controller.syncTraceMatches(CleanSyncs, sizeof(CleanSyncs));
  if (read) {
    fixture.disk.unpin(CheckedSyncLocation);
  }
  fixture.disk.resumeBackgroundWriteback();
  const bool cleanBackground = fixture.disk.runBackgroundWriteback() &&
                               fixture.controller.hasNoDirectActivity() &&
                               fixture.controller.syncTraceMatches(CleanSyncs, sizeof(CleanSyncs));
  fixture.disk.pauseBackgroundWriteback();
  auto writer = fixture.disk.writeView(CheckedSyncLocation);
  const uint8_t value = 0x7d;
  const bool changed = writer && writer.writeAt(value, 0);
  writer.reset();
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  fixture.controller.beginSync(SyncMode::FailAll);
  fixture.disk.beginUnpinObservation();
  const bool failed = !fixture.disk.sync(CheckedSyncLocation, false);
  const size_t failureUnpins = fixture.disk.endUnpinObservation();
  const bool failureReported =
      failed && failureUnpins == 0 &&
      fixture.controller.directTupleMatches(&fixture.disk, CheckedSyncLocation, page) &&
      fixture.controller.writeTraceMatches(SuccessfulWrites, sizeof(SuccessfulWrites)) &&
      fixture.controller.syncTraceMatches(FailedSyncs, sizeof(FailedSyncs));
 
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  fixture.controller.beginSync(SyncMode::FailAll);
  const bool retained =
      !fixture.disk.evictPage(CheckedSyncLocation) && fixture.disk.hasPage(CheckedSyncLocation) &&
      fixture.disk.pageAddress(CheckedSyncLocation) == page &&
      fixture.controller.directTupleMatches(&fixture.disk, CheckedSyncLocation, page) &&
      fixture.controller.writeTraceMatches(SuccessfulWrites, sizeof(SuccessfulWrites)) &&
      fixture.controller.syncTraceMatches(FailedSyncs, sizeof(FailedSyncs));
 
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  fixture.controller.beginSync(SyncMode::Pass16);
  const bool pinned = fixture.disk.pin(CheckedSyncLocation);
  fixture.disk.beginUnpinObservation();
  const bool retried = fixture.disk.sync(CheckedSyncLocation, false);
  const size_t retryUnpins = fixture.disk.endUnpinObservation();
  const bool retryReported =
      retried && retryUnpins == 0 &&
      fixture.controller.directTupleMatches(&fixture.disk, CheckedSyncLocation, page) &&
      fixture.controller.writeTraceMatches(SuccessfulWrites, sizeof(SuccessfulWrites)) &&
      fixture.controller.syncTraceMatches(RetriedSyncs, sizeof(RetriedSyncs));
  const bool callerPinPreserved = pinned && !fixture.disk.evictPage(CheckedSyncLocation);
  if (pinned) {
    fixture.disk.unpin(CheckedSyncLocation);
  }
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  fixture.controller.beginSync(SyncMode::Pass10);
  const bool repeated = fixture.disk.sync(CheckedSyncLocation, false) &&
                        fixture.disk.sync(CheckedSyncLocation, false) &&
                        fixture.controller.hasNoDirectActivity() &&
                        fixture.controller.syncTraceMatches(CleanSyncs, sizeof(CleanSyncs));
  fixture.disk.resumeBackgroundWriteback();
  const bool cleaned =
      fixture.disk.runBackgroundWriteback() && fixture.disk.evictPage(CheckedSyncLocation) &&
      !fixture.disk.hasPage(CheckedSyncLocation) && fixture.controller.hasNoDirectActivity() &&
      fixture.controller.syncTraceMatches(CleanSyncs, sizeof(CleanSyncs));
  const bool passed = cleanSynced && cleanBackground && changed && failureReported && retained &&
                      retryReported && callerPinPreserved && repeated && cleaned;
  if (passed) {
    NOTICE("HOSTED-WAIT-TEST: PASS scsi-checked-sync");
  } else {
    ERROR(
        "HOSTED-WAIT-TEST: FAIL scsi-checked-sync: clean writes, error retention, retry, or "
        "borrowed pin ownership");
  }
  return passed;
}
 
bool scsiSyncAll() {
  constexpr uint64_t WholeRequest[] = {ScsiDisk::SyncWholeDevice};
  constexpr uint64_t PageThenWhole[] = {CheckedSyncLocation, ScsiDisk::SyncWholeDevice};
  constexpr uint8_t Pass10[] = {0x35};
  constexpr uint8_t Pass16[] = {0x35, 0x35, 0x35, 0x91};
  constexpr uint8_t FailAll[] = {0x35, 0x35, 0x35, 0x91, 0x91, 0x91};
  constexpr uint8_t PageAndWhole[] = {0x35, 0x35};
  constexpr uint8_t FinalFailed[] = {0x35, 0x35, 0x35, 0x35, 0x91, 0x91, 0x91};
  constexpr bool WholeGeometry[] = {true, true, true, true, true, true};
  constexpr bool PageAndWholeGeometry[] = {false, true};
  constexpr bool FinalFailedGeometry[] = {false, true, true, true, true, true, true};
  constexpr uint8_t FailedWrites[] = {0x2a, 0x2a, 0x2a, 0xaa, 0xaa, 0xaa, 0x8a, 0x8a, 0x8a};
  constexpr uint8_t SuccessfulWrites[] = {0x2a, 0x2a, 0x2a, 0xaa};
  Fixture fixture;
  if (!fixture.ready) {
    ERROR("HOSTED-WAIT-TEST: FAIL scsi-sync-all: fixture setup");
    return false;
  }
 
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  fixture.controller.beginSync(SyncMode::Pass10);
  const bool emptyFlushed = fixture.disk.syncAll() && fixture.controller.writeCount() == 0 &&
                            fixture.controller.syncRequestsMatch(WholeRequest, 1) &&
                            fixture.controller.syncTraceMatches(Pass10, sizeof(Pass10)) &&
                            fixture.controller.syncGeometryMatches(WholeGeometry, 1);
  fixture.controller.beginSync(SyncMode::FailAll);
  const bool emptyFailure = !fixture.disk.syncAll() &&
                            fixture.controller.syncRequestsMatch(WholeRequest, 1) &&
                            fixture.controller.syncTraceMatches(FailAll, sizeof(FailAll)) &&
                            fixture.controller.syncGeometryMatches(WholeGeometry, 6);
  fixture.controller.beginSync(SyncMode::Pass16);
  const bool emptyRetry = fixture.disk.syncAll() &&
                          fixture.controller.syncRequestsMatch(WholeRequest, 1) &&
                          fixture.controller.syncTraceMatches(Pass16, sizeof(Pass16)) &&
                          fixture.controller.syncGeometryMatches(WholeGeometry, 4);
 
  const bool prepared = fixture.disk.preparePage(CheckedSyncLocation);
  fixture.controller.beginWrites(WriteMode::FailAll);
  fixture.controller.beginSync(SyncMode::Pass10);
  const bool pageFailed =
      prepared && !fixture.disk.syncAll() && fixture.disk.hasPage(CheckedSyncLocation) &&
      fixture.controller.writeTraceMatches(FailedWrites, sizeof(FailedWrites)) &&
      fixture.controller.syncRequestsMatch(PageThenWhole, 2) &&
      fixture.controller.syncTraceMatches(PageAndWhole, sizeof(PageAndWhole)) &&
      fixture.controller.syncGeometryMatches(PageAndWholeGeometry, 2);
 
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  fixture.controller.beginSync(SyncMode::FailWhole);
  const bool finalFailed =
      !fixture.disk.syncAll() && fixture.disk.hasPage(CheckedSyncLocation) &&
      fixture.controller.writeTraceMatches(SuccessfulWrites, sizeof(SuccessfulWrites)) &&
      fixture.controller.syncRequestsMatch(PageThenWhole, 2) &&
      fixture.controller.syncTraceMatches(FinalFailed, sizeof(FinalFailed)) &&
      fixture.controller.syncGeometryMatches(FinalFailedGeometry, 7);
 
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  fixture.controller.beginSync(SyncMode::Pass10);
  const bool retried =
      fixture.disk.syncAll() &&
      fixture.controller.writeTraceMatches(SuccessfulWrites, sizeof(SuccessfulWrites)) &&
      fixture.controller.syncRequestsMatch(PageThenWhole, 2) &&
      fixture.controller.syncTraceMatches(PageAndWhole, sizeof(PageAndWhole)) &&
      fixture.controller.syncGeometryMatches(PageAndWholeGeometry, 2);
  const bool cleaned = fixture.disk.evictPage(CheckedSyncLocation);
  const bool passed =
      emptyFlushed && emptyFailure && emptyRetry && pageFailed && finalFailed && retried && cleaned;
  if (passed) {
    NOTICE("HOSTED-WAIT-TEST: PASS scsi-sync-all");
  } else {
    ERROR("HOSTED-WAIT-TEST: FAIL scsi-sync-all: empty="
          << emptyFlushed << ", empty-failure=" << emptyFailure << ", empty-retry=" << emptyRetry
          << ", prepared=" << prepared << ", page-failure=" << pageFailed
          << ", final-failure=" << finalFailed << ", retry=" << retried << ", cleanup=" << cleaned);
  }
  return passed;
}
 
bool scsiSyncBatch(bool failWrite, bool failFlush) {
  constexpr uint64_t Keys[] = {CheckedSyncLocation, CheckedSyncLocation + PageBytes};
  constexpr uint8_t Flush[] = {0x35};
  constexpr uint8_t FailedFlush[] = {0x35, 0x35, 0x35, 0x91, 0x91, 0x91};
  constexpr bool Whole[] = {true, true, true, true, true, true};
  Fixture fixture;
  if (!fixture.ready)
    return false;
  fixture.disk.pauseBackgroundWriteback();
  if (!fixture.disk.preparePage(Keys[0]) || !fixture.disk.preparePage(Keys[1]))
    return false;
  for (uint64_t key : Keys)
    fixture.disk.write(key);
  fixture.controller.beginWrites(failWrite ? WriteMode::FailAll : WriteMode::PassWrite12);
  fixture.controller.beginSync(failFlush ? SyncMode::FailAll : SyncMode::Pass10);
  const bool result = fixture.disk.syncPages(Keys, 2);
  const size_t expectedWrites = failWrite ? 18 : 8;
  const bool committed =
      result == !(failWrite || failFlush) && fixture.controller.writeCount() == expectedWrites &&
      fixture.controller.writesAtLastSync() == expectedWrites &&
      fixture.controller.syncTraceMatches(failFlush ? FailedFlush : Flush, failFlush ? 6 : 1) &&
      fixture.controller.syncGeometryMatches(Whole, failFlush ? 6 : 1);
  bool retained = true;
  if (failWrite || failFlush) {
    // A failed common barrier keeps even successfully transferred pages dirty.
    // A backend attempt on each eviction also detects a leaked batch pin.
    for (uint64_t key : Keys) {
      fixture.controller.beginWrites(WriteMode::PassWrite12);
      fixture.controller.beginSync(SyncMode::FailAll);
      retained = !fixture.disk.evictPage(key) && fixture.disk.hasPage(key) &&
                 fixture.controller.writeCount() == 4 &&
                 fixture.controller.syncTraceMatches(FailedFlush, sizeof(FailedFlush)) && retained;
    }
  }
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  fixture.controller.beginSync(SyncMode::Pass10);
  const bool pinned = fixture.disk.pin(Keys[0]);
  const bool needsRetry = failWrite || failFlush;
  const size_t retryWrites = needsRetry ? 8 : 0;
  const bool retried = fixture.disk.syncPages(Keys, 2) &&
                       fixture.controller.writeCount() == retryWrites &&
                       fixture.controller.writesAtLastSync() == retryWrites &&
                       fixture.controller.syncTraceMatches(Flush, needsRetry ? sizeof(Flush) : 0);
  const bool callerPin = pinned && !fixture.disk.evictPage(Keys[0]);
  if (pinned)
    fixture.disk.unpin(Keys[0]);
  const bool balanced = fixture.disk.evictPage(Keys[0]) && fixture.disk.evictPage(Keys[1]) &&
                        fixture.controller.writeCount() == retryWrites &&
                        fixture.controller.syncTraceMatches(Flush, needsRetry ? sizeof(Flush) : 0);
  const bool passed = committed && retained && retried && callerPin && balanced;
  if (passed)
    NOTICE("HOSTED-WAIT-TEST: PASS scsi-sync-batch write-failure="
           << failWrite << ", flush-failure=" << failFlush);
  else
    ERROR("HOSTED-WAIT-TEST: FAIL scsi-sync-batch: commit="
          << committed << ", retained=" << retained << ", retry=" << retried
          << ", caller-pin=" << callerPin << ", balanced=" << balanced);
  return passed;
}
 
struct SyncBatchContext {
  HostedScsiDisk* disk;
  uint64_t keys[2];
  Atomic<size_t> entered{0};
  Atomic<size_t> returned{0};
  bool result = false;
};
 
int syncBatchPages(void* parameter) {
  auto& context = *static_cast<SyncBatchContext*>(parameter);
  context.entered = 1;
  context.result = context.disk->syncPages(context.keys, 2);
  context.returned = 1;
  return 0;
}
 
bool scsiOverlappingSyncBatches() {
  constexpr uint64_t First = CheckedSyncLocation;
  constexpr uint64_t Second = First + PageBytes;
  constexpr uint8_t Flushes[] = {0x35, 0x35};
  constexpr bool Whole[] = {true, true};
  Fixture fixture;
  if (!fixture.ready)
    return false;
  fixture.disk.pauseBackgroundWriteback();
  if (!fixture.disk.preparePage(First) || !fixture.disk.preparePage(Second))
    return false;
  fixture.disk.write(First);
  fixture.disk.write(Second);
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  fixture.controller.beginSync(SyncMode::Pass10);
  fixture.controller.holdNextSync();
  SyncBatchContext first{&fixture.disk, {First, Second}};
  SyncBatchContext second{&fixture.disk, {Second, First}};
  Thread* producer = new Thread(Scheduler::instance().getKernelProcess(), syncBatchPages, &first,
                                nullptr, false, true);
  producer->setName("hosted SCSI held batch barrier");
  const bool held = fixture.controller.waitForHeldSync();
  Thread* waiter = nullptr;
  bool waiting = false;
  if (held) {
    waiter = new Thread(Scheduler::instance().getKernelProcess(), syncBatchPages, &second, nullptr,
                        false, true);
    waiter->setName("hosted SCSI overlapping reverse batch");
    const Time::Timestamp deadline = Time::getTicks() + (500 * Time::Multiplier::Millisecond);
    while (Time::getTicks() < deadline) {
      Thread::WaitDebugInfo info = {};
      uintptr_t address = 0;
      if (waiter->getWaitDebugInfo(info) && info.queue && info.queued &&
          waiter->getDebugState(address) == Thread::CallbackDrain) {
        waiting = true;
        break;
      }
      if (second.returned)
        break;
      Scheduler::instance().yield();
    }
  }
  const bool excluded = held && waiting && !first.returned && !second.returned &&
                        fixture.controller.writeCount() == 8 && !fixture.disk.evictPage(First) &&
                        !fixture.disk.evictPage(Second);
  fixture.disk.write(First);
  fixture.disk.write(Second);
  fixture.controller.releaseHeldSync();
  const bool firstCompleted = waitUntilSet(first.returned);
  const bool secondCompleted = waiter && waitUntilSet(second.returned);
  const bool firstJoined = producer->joinForCompletion();
  const bool secondJoined = waiter && waiter->joinForCompletion();
  const bool serialised = firstCompleted && secondCompleted && firstJoined && secondJoined &&
                          first.result && second.result && fixture.controller.writeCount() == 16 &&
                          fixture.controller.writesAtLastSync() == 16 &&
                          fixture.controller.syncTraceMatches(Flushes, sizeof(Flushes)) &&
                          fixture.controller.syncGeometryMatches(Whole, 2);
  const bool balanced = fixture.disk.evictPage(First) && fixture.disk.evictPage(Second) &&
                        fixture.controller.writeCount() == 16;
  const bool passed = excluded && serialised && balanced;
  if (passed)
    NOTICE("HOSTED-WAIT-TEST: PASS scsi-overlapping-sync-batches");
  else
    ERROR("HOSTED-WAIT-TEST: FAIL scsi-overlapping-sync-batches: excluded="
          << excluded << ", serialised=" << serialised << ", balanced=" << balanced);
  return passed;
}
 
bool scsiSyncBatchValidation() {
  constexpr uint64_t Key = CheckedSyncLocation;
  constexpr uint64_t Duplicate[] = {Key, Key + 512, Key + 1024};
  constexpr uint64_t Missing[] = {Key, Key + PageBytes};
  constexpr uint64_t Outside[] = {Key, 64 * PageBytes};
  constexpr uint64_t Overflow[] = {Key, ~uint64_t{0}};
  constexpr uint8_t Flush[] = {0x35};
  Fixture fixture;
  if (!fixture.ready)
    return false;
  fixture.disk.pauseBackgroundWriteback();
  if (!fixture.disk.preparePage(Key))
    return false;
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  fixture.controller.beginSync(SyncMode::Pass10);
  const bool rejected = fixture.disk.syncPages(nullptr, 0) && !fixture.disk.syncPages(nullptr, 1) &&
                        !fixture.disk.syncPages(Duplicate, Cache::MaxWritebackPages + 1) &&
                        !fixture.disk.syncPages(Missing, 2) &&
                        !fixture.disk.syncPages(Outside, 2) && !fixture.disk.syncPages(Overflow, 2);
  const bool editing = fixture.disk.prepareEditingPage(Key + PageBytes) &&
                       !fixture.disk.syncPages(Missing, 2) &&
                       fixture.disk.discardEditingPage(Key + PageBytes);
  const bool noIo =
      fixture.controller.hasNoDirectActivity() && fixture.controller.syncTraceMatches(nullptr, 0);
  fixture.disk.write(Key);
  const bool deduplicated = fixture.disk.syncPages(Duplicate, 3) &&
                            fixture.controller.writeCount() == 4 &&
                            fixture.controller.writesAtLastSync() == 4 &&
                            fixture.controller.syncTraceMatches(Flush, sizeof(Flush));
  const bool balanced = fixture.disk.evictPage(Key) && fixture.controller.writeCount() == 4;
  const bool passed = rejected && editing && noIo && deduplicated && balanced;
  if (passed)
    NOTICE("HOSTED-WAIT-TEST: PASS scsi-sync-batch-validation");
  else
    ERROR("HOSTED-WAIT-TEST: FAIL scsi-sync-batch-validation: rejected="
          << rejected << ", editing=" << editing << ", no-io=" << noIo << ", dedup=" << deduplicated
          << ", balanced=" << balanced);
  return passed;
}
 
bool scsiSyncBatchTerminalGeometry() {
  constexpr uint64_t Terminal = 4 * PageBytes;
  constexpr size_t TerminalBytes = 512;
  constexpr uint64_t Keys[] = {0, Terminal};
  constexpr uint8_t Flush[] = {0x35};
  constexpr bool Whole[] = {true};
  ScriptedScsiController controller(Terminal + TerminalBytes);
  HostedScsiDisk disk;
  if (!disk.initialise(&controller, 0))
    return false;
  disk.pauseBackgroundWriteback();
  if (!disk.preparePage(Keys[0]) || !disk.preparePage(Keys[1]))
    return false;
  for (uint64_t key : Keys)
    disk.write(key);
  controller.beginWrites(WriteMode::PassWrite12);
  controller.beginSync(SyncMode::Pass10);
  const bool written =
      disk.syncPages(Keys, 2) && controller.writeCount() == 8 &&
      controller.lastWriteBytes() == TerminalBytes && controller.writesAtLastSync() == 8 &&
      controller.syncTraceMatches(Flush, sizeof(Flush)) && controller.syncGeometryMatches(Whole, 1);
  const bool balanced =
      disk.evictPage(Keys[0]) && disk.evictPage(Keys[1]) && controller.writeCount() == 8;
  const bool passed = written && balanced;
  if (passed)
    NOTICE("HOSTED-WAIT-TEST: PASS scsi-sync-batch-terminal");
  else
    ERROR("HOSTED-WAIT-TEST: FAIL scsi-sync-batch-terminal: write bounds, final flush or pins");
  return passed;
}
 
bool scsiTerminalCachePage() {
  constexpr size_t TerminalBytes = 512;
  constexpr uint64_t TerminalLocation = 4 * PageBytes;
  constexpr uint8_t SuccessfulOpcodes[] = {0x2a, 0x2a, 0x2a, 0xaa};
 
  ScriptedScsiController controller(TerminalLocation + TerminalBytes);
  HostedScsiDisk disk;
  const bool ready = disk.initialise(&controller, 0);
  controller.beginRequestTrace();
  const BufferView view = ready ? disk.read(TerminalLocation) : BufferView();
 
  bool payloadValid =
      view && view.size() == TerminalBytes && controller.lastReadBytes() == TerminalBytes;
  bool tailZeroed = payloadValid;
  const uint8_t* page = payloadValid ? reinterpret_cast<const uint8_t*>(view.data()) : nullptr;
  for (size_t i = 0; page && i < TerminalBytes; ++i) {
    if (page[i] != 0x3c) {
      payloadValid = false;
      break;
    }
  }
  for (size_t i = TerminalBytes; page && i < PageBytes; ++i) {
    if (page[i]) {
      tailZeroed = false;
      break;
    }
  }
  if (view) {
    disk.unpin(TerminalLocation);
  }
 
  controller.beginWrites(WriteMode::PassWrite12);
  const bool retired = ready && disk.retireCachePage(TerminalLocation);
  const bool boundedWriteback =
      retired && controller.lastWriteBytes() == TerminalBytes &&
      controller.writeTraceMatches(SuccessfulOpcodes, sizeof(SuccessfulOpcodes)) &&
      !disk.hasPage(TerminalLocation);
 
  const bool passed = ready && payloadValid && tailZeroed && boundedWriteback;
  if (passed) {
    NOTICE("HOSTED-WAIT-TEST: PASS scsi-terminal-cache-page");
  } else {
    ERROR(
        "HOSTED-WAIT-TEST: FAIL scsi-terminal-cache-page: terminal read length, zero fill, or "
        "writeback bounds changed");
  }
  return passed;
}
 
bool producerBytesMatch(const uint8_t* bytes, size_t length, uint8_t value) {
  for (size_t i = 0; i < length; ++i) {
    if (bytes[i] != value)
      return false;
  }
  return true;
}
 
bool scsiProducerReadBatchCoherence() {
  constexpr uint64_t Cached = 4 * PageBytes;
  constexpr uint64_t FirstAbsent = 16 * PageBytes + 512;
  constexpr uint64_t SecondAbsent = 32 * PageBytes;
  constexpr uint64_t ExpectedPending[] = {FirstAbsent, SecondAbsent, FirstAbsent};
  Fixture fixture;
  if (!fixture.ready)
    return false;
  fixture.disk.pauseBackgroundWriteback();
  fixture.disk.enableBufferTransfers();
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  if (!fixture.disk.preparePage(Cached))
    return false;
  const BufferView loan = fixture.disk.read(Cached);
  if (!loan)
    return false;
  ByteSet(static_cast<uint8_t*>(loan.data()) + 512, 0xc7, 512);
  fixture.disk.write(Cached);
  fixture.controller.beginRequestTrace();
  fixture.disk.beginReadBufferBatch();
 
  uint8_t output[5][514];
  ByteSet(output, 0x3f, sizeof(output));
  Disk::ReadBuffer requests[] = {{Cached + 512, output[0] + 1, 512, false},
                                 {FirstAbsent, output[1] + 1, 512, false},
                                 {SecondAbsent, output[2] + 1, 512, false},
                                 {FirstAbsent, output[3] + 1, 512, false},
                                 {Cached + 1024, output[4] + 1, 512, false}};
  bool passed = fixture.disk.readIntoBatch(requests, 5) &&
                fixture.disk.bufferBatchMatches(ExpectedPending, 3) &&
                fixture.disk.bufferTransferCount() == 3 && !fixture.controller.readCommandCount() &&
                !fixture.controller.writeCount() && fixture.disk.hasPage(Cached) &&
                !fixture.disk.hasPage(16 * PageBytes) && !fixture.disk.hasPage(SecondAbsent) &&
                !fixture.disk.hasNoCacheLoans();
  for (size_t i = 0; i < 5; ++i) {
    const uint8_t expected = !i ? 0xc7 : i == 4 ? 0x5a : 0xa6;
    passed = passed && requests[i].complete && producerBytesMatch(output[i] + 1, 512, expected) &&
             output[i][0] == 0x3f && output[i][513] == 0x3f;
  }
 
  ByteSet(static_cast<uint8_t*>(loan.data()) + 512, 0xd8, 512);
  fixture.disk.write(Cached);
  fixture.disk.beginReadBufferBatch();
  passed = fixture.disk.readIntoBatch(requests, 1) && requests[0].complete &&
           producerBytesMatch(output[0] + 1, 512, 0xd8) && !fixture.disk.bufferBatchCount() &&
           !fixture.disk.bufferTransferCount() && !fixture.controller.readCommandCount() && passed;
  fixture.disk.unpin(Cached);
  passed = fixture.disk.hasNoCacheLoans() && passed;
  if (passed)
    NOTICE("HOSTED-WAIT-TEST: PASS scsi-producer-read-batch-coherence");
  else
    ERROR("HOSTED-WAIT-TEST: FAIL scsi-producer-read-batch-coherence");
  return passed;
}
 
bool scsiProducerReadBatchFailure() {
  constexpr uint64_t Locations[] = {4 * PageBytes, 8 * PageBytes, 12 * PageBytes};
  Fixture fixture;
  if (!fixture.ready)
    return false;
  fixture.disk.enableBufferTransfers();
  fixture.disk.beginReadBufferBatch(Locations[1]);
  uint8_t output[3][514];
  ByteSet(output, 0x3f, sizeof(output));
  Disk::ReadBuffer requests[3];
  for (size_t i = 0; i < 3; ++i)
    requests[i] = {Locations[i], output[i] + 1, 512, true};
  bool passed = !fixture.disk.readIntoBatch(requests, 3) &&
                fixture.disk.bufferBatchMatches(Locations, 3) &&
                fixture.disk.bufferTransferCount() == 3;
  for (size_t i = 0; i < 3; ++i) {
    passed = passed && requests[i].complete == (i != 1) &&
             producerBytesMatch(output[i] + 1, 512, i == 1 ? 0x3f : 0xa6) && output[i][0] == 0x3f &&
             output[i][513] == 0x3f && !fixture.disk.hasPage(Locations[i]);
  }
  fixture.disk.beginReadBufferBatch();
  passed = fixture.disk.readIntoBatch(requests, 3) &&
           fixture.disk.bufferBatchMatches(Locations, 3) &&
           fixture.disk.bufferTransferCount() == 3 && passed;
  for (size_t i = 0; i < 3; ++i)
    passed = passed && requests[i].complete && producerBytesMatch(output[i] + 1, 512, 0xa6);
  passed = fixture.disk.hasNoCacheLoans() && passed;
  if (passed)
    NOTICE("HOSTED-WAIT-TEST: PASS scsi-producer-read-batch-failure");
  else
    ERROR("HOSTED-WAIT-TEST: FAIL scsi-producer-read-batch-failure");
  return passed;
}
 
enum class ReadBatchFallback { Unsupported, Unaligned, NativeSector, PageCrossing, ShiftedOrigin };
 
bool scsiProducerReadBatchFallbackCase(ReadBatchFallback mode) {
  const size_t native = mode == ReadBatchFallback::NativeSector ? PageBytes : 512;
  ScriptedScsiController controller(64 * PageBytes, native);
  HostedScsiDisk disk;
  if (!disk.initialise(&controller, 0))
    return false;
  disk.pauseBackgroundWriteback();
  if (mode != ReadBatchFallback::Unsupported)
    disk.enableBufferTransfers();
  controller.beginWrites(WriteMode::PassWrite12);
  uint64_t locations[] = {0, 8 * PageBytes};
  size_t lengths[] = {512, 512};
  uint8_t expected = 0x3c;
  BufferView loan;
  if (mode == ReadBatchFallback::Unaligned) {
    ++locations[0];
    locations[1] += 3;
    lengths[0] = lengths[1] = 7;
  } else if (mode == ReadBatchFallback::NativeSector) {
    locations[0] += 512;
    locations[1] += 1024;
  } else if (mode == ReadBatchFallback::PageCrossing) {
    lengths[0] = PageBytes + 512;
    expected = 0xa6;
  } else if (mode == ReadBatchFallback::ShiftedOrigin) {
    locations[0] = 1536;
    locations[1] = 2048;
    disk.align(locations[0]);
    if (!disk.preparePage(locations[0]))
      return false;
    loan = disk.read(locations[0]);
    if (!loan)
      return false;
    ByteSet(loan.data(), 0xc7, PageBytes);
    disk.write(locations[0]);
    expected = 0xc7;
  }
  auto first = UniqueArray<uint8_t>::allocate(lengths[0] + 2);
  auto second = UniqueArray<uint8_t>::allocate(lengths[1] + 2);
  ByteSet(first.get(), 0x3f, lengths[0] + 2);
  ByteSet(second.get(), 0x3f, lengths[1] + 2);
  Disk::ReadBuffer requests[] = {{locations[0], first.get() + 1, lengths[0], true},
                                 {locations[1], second.get() + 1, lengths[1], true}};
  disk.beginReadBufferBatch();
  const bool passed =
      disk.readIntoBatch(requests, 2) && requests[0].complete && requests[1].complete &&
      !disk.bufferBatchCount() &&
      disk.bufferTransferCount() == (mode == ReadBatchFallback::PageCrossing ? 3U : 0U) &&
      producerBytesMatch(first.get() + 1, lengths[0], expected) &&
      producerBytesMatch(second.get() + 1, lengths[1], expected) && first.get()[0] == 0x3f &&
      first.get()[lengths[0] + 1] == 0x3f && second.get()[0] == 0x3f &&
      second.get()[lengths[1] + 1] == 0x3f &&
      (!loan || producerBytesMatch(static_cast<uint8_t*>(loan.data()), PageBytes, 0xc7));
  if (loan)
    disk.unpin(locations[0]);
  if (!passed)
    ERROR(
        "HOSTED-WAIT-TEST: FAIL scsi-producer-read-batch-fallback mode=" << static_cast<int>(mode));
  return passed && disk.hasNoCacheLoans();
}
 
bool scsiProducerReadBatchFallbacks() {
  const ReadBatchFallback modes[] = {
      ReadBatchFallback::Unsupported, ReadBatchFallback::Unaligned, ReadBatchFallback::NativeSector,
      ReadBatchFallback::PageCrossing, ReadBatchFallback::ShiftedOrigin};
  for (auto mode : modes) {
    if (!scsiProducerReadBatchFallbackCase(mode))
      return false;
  }
  NOTICE("HOSTED-WAIT-TEST: PASS scsi-producer-read-batch-fallbacks");
  return true;
}
 
bool scsiProducerShiftedOriginFallback() {
  constexpr uint64_t ShiftedOrigin = 1536;
  constexpr uint64_t LaterPage = 4 * PageBytes;
  Fixture fixture;
  if (!fixture.ready)
    return false;
  fixture.disk.pauseBackgroundWriteback();
  fixture.disk.enableBufferTransfers();
  fixture.controller.beginWrites(WriteMode::PassWrite12);
  fixture.controller.beginSync(SyncMode::Pass10);
  uint8_t buffer[1024] = {};
 
  fixture.disk.align(PageBytes);
  const bool alignedFastPath = fixture.disk.readInto(LaterPage, buffer, 512) && buffer[0] == 0xa6 &&
                               fixture.disk.bufferTransferCount() == 1 &&
                               !fixture.disk.hasPage(LaterPage);
 
  fixture.disk.align(ShiftedOrigin);
  const bool prepared = fixture.disk.preparePage(ShiftedOrigin);
  const BufferView loan = prepared ? fixture.disk.read(ShiftedOrigin) : BufferView();
  if (loan) {
    static_cast<uint8_t*>(loan.data())[0] = 0xc7;
    fixture.disk.write(ShiftedOrigin);
  }
 
  // Even bytes before the origin can occupy a page overlapping its cache key.
  const bool beforeOrigin = fixture.disk.readInto(0, buffer, 512);
  const bool acrossOrigin = fixture.disk.readInto(1024, buffer, sizeof(buffer));
  const bool afterAlignedOrigin = fixture.disk.readInto(LaterPage, buffer, 512);
  const bool dirtyLoanVisible =
      loan && fixture.disk.readInto(ShiftedOrigin, buffer, 512) && buffer[0] == 0xc7;
  ByteSet(buffer, 0xd2, sizeof(buffer));
  const bool loanUpdated = loan && fixture.disk.writeFrom(ShiftedOrigin, buffer, 512) &&
                           static_cast<const uint8_t*>(loan.data())[0] == 0xd2 &&
                           static_cast<const uint8_t*>(loan.data())[512] == 0x5a;
  const bool crossWrite = fixture.disk.writeFrom(1024, buffer, sizeof(buffer));
  const bool legacyOnly = fixture.disk.bufferTransferCount() == 1 && fixture.disk.hasPage(0) &&
                          fixture.disk.hasPage(ShiftedOrigin) && fixture.disk.hasPage(LaterPage);
  if (loan)
    fixture.disk.unpin(ShiftedOrigin);
 
  const bool passed = alignedFastPath && prepared && beforeOrigin && acrossOrigin &&
                      afterAlignedOrigin && dirtyLoanVisible && loanUpdated && crossWrite &&
                      legacyOnly;
  if (passed) {
    NOTICE("HOSTED-WAIT-TEST: PASS scsi-producer-shifted-origin-fallback");
  } else {
    ERROR("HOSTED-WAIT-TEST: FAIL scsi-producer-shifted-origin-fallback: aligned="
          << alignedFastPath << ", prepared=" << prepared << ", before=" << beforeOrigin
          << ", across=" << acrossOrigin << ", after=" << afterAlignedOrigin
          << ", dirty-loan=" << dirtyLoanVisible << ", updated=" << loanUpdated
          << ", cross-write=" << crossWrite << ", legacy=" << legacyOnly);
  }
  return passed;
}
 
bool scsiOpticalReadAfterToc() {
  constexpr size_t OpticalBlockBytes = 2048;
  constexpr uint64_t VolumeDescriptorLocation = 16 * OpticalBlockBytes;
 
  ScriptedScsiController controller(64 * PageBytes, OpticalBlockBytes, true);
  HostedScsiDisk disk;
  const bool ready = disk.initialise(&controller, 0);
  controller.beginRequestTrace();
  const BufferView view = ready ? disk.read(VolumeDescriptorLocation) : BufferView();
 
  bool payloadValid = view && view.size() == PageBytes;
  const uint8_t* payload = payloadValid ? reinterpret_cast<const uint8_t*>(view.data()) : nullptr;
  for (size_t i = 0; payload && i < view.size(); ++i) {
    if (payload[i] != 0x3c) {
      payloadValid = false;
      break;
    }
  }
  if (view) {
    disk.unpin(VolumeDescriptorLocation);
  }
 
  const bool passed = ready && payloadValid && controller.readTocCount() == 1 &&
                      controller.readRequestCount() == 1 && controller.readCommandCount() == 1 &&
                      controller.lastReadOpcode() == 0x28 &&
                      controller.lastReadBytes() == PageBytes;
  if (passed) {
    NOTICE("HOSTED-WAIT-TEST: PASS scsi-optical-read-after-toc");
  } else {
    ERROR(
        "HOSTED-WAIT-TEST: FAIL scsi-optical-read-after-toc: successful READ TOC suppressed "
        "the media READ(10) or published an empty cache page");
  }
  return passed;
}
 
bool scsiRejectsNativeBlocksLargerThanCachePages() {
  ScriptedScsiController controller(64 * PageBytes, 2 * PageBytes);
  HostedScsiDisk disk;
  const bool passed = !disk.initialise(&controller, 0);
  if (passed) {
    NOTICE("HOSTED-WAIT-TEST: PASS scsi-larger-native-block-rejected");
  } else {
    ERROR(
        "HOSTED-WAIT-TEST: FAIL scsi-larger-native-block-rejected: a native block spanning "
        "independently owned cache pages was accepted without an RMW contract");
  }
  return passed;
}
}  // namespace
 
EXPORTED_PUBLIC bool runHostedScsiSyncRegressions() {
  const bool scopedViews = scsiScopedDiskViews();
  const bool viewAlignment = scsiViewSurvivesAlignmentChange();
  const bool deferredWrites = scsiDeferredWrites();
  const bool deferredRetry = scsiDeferredWriteRetry();
  const bool deferredShutdown = scsiDeferredWriteShutdown();
  const bool syncAll = scsiSyncAll();
  const bool batch = scsiSyncBatch(false, false);
  const bool batchWriteFailure = scsiSyncBatch(true, false);
  const bool batchFlushFailure = scsiSyncBatch(false, true);
  const bool overlappingBatches = scsiOverlappingSyncBatches();
  const bool batchValidation = scsiSyncBatchValidation();
  const bool batchTerminal = scsiSyncBatchTerminalGeometry();
  const bool producerAlignment = scsiProducerShiftedOriginFallback();
  const bool producerReads = scsiProducerReadBatchCoherence();
  const bool producerReadFailure = scsiProducerReadBatchFailure();
  const bool producerReadFallbacks = scsiProducerReadBatchFallbacks();
  return scopedViews && viewAlignment && deferredWrites && deferredRetry && deferredShutdown &&
         syncAll && batch && batchWriteFailure && batchFlushFailure && overlappingBatches &&
         batchValidation && batchTerminal && producerAlignment && producerReads &&
         producerReadFailure && producerReadFallbacks;
}
 
EXPORTED_PUBLIC bool runHostedScsiWriteRegressions() {
  Fixture fixture;
  const bool ataOwnership = ataQueuedWriteCacheOwnership(fixture);
  const bool scsiResult = scsiWriteResult(fixture);
  const bool directResult = scsiDirectRetireResult(fixture);
  const bool directOwnership = scsiDirectRetireOwnership(fixture);
  const bool readRetireAdmission = scsiReadRetireAdmission(fixture);
  const bool retireReadRecheck = scsiRetireReadRecheck(fixture);
  const bool checkedSync = scsiCheckedSync();
  const bool syncAll = runHostedScsiSyncRegressions();
  const bool terminalPage = scsiTerminalCachePage();
  const bool opticalRead = scsiOpticalReadAfterToc();
  const bool largerNativeRejected = scsiRejectsNativeBlocksLargerThanCachePages();
  return ataOwnership && scsiResult && directResult && directOwnership && readRetireAdmission &&
         retireReadRecheck && checkedSync && syncAll && terminalPage && opticalRead &&
         largerNativeRejected;
}