Macintosh-HW/RASCSI
1
0
Fork 0
mirror of https://github.com/akuker/RASCSI.git synced 2026-04-19 20:16:52 +00:00
Code Issues Projects Releases Wiki Activity

Add support for drives larger than 2 TB (Closes: #1551)

Browse Source 
Mode Sense (6) supports a 32-bit number for the maximum block count, where Mode Sense (10) supports a 64-bit number for the count. The Seagate SCSI Commands Reference Manual from 2016, has this to say about a "Short LBA mode parameter block descriptor" as returned by Mode Sense (6):

>  On a MODE SENSE command, if the number of logical blocks on the
>  medium exceeds the maximum value that is able to be specified in
>  the NUMBER OF LOGICAL BLOCKS field, the device server shall return
>  a value of FFFFFFFh.

Similarly, the Read Capacity (10) command should return FFFFFFFFh if the capacity of the drive exceeds 2^32 sectors, and that a driver should then know to use Read Capacity (16) if it supports that command.

There may be an unexpected side-effect if presenting a drive of more than 2^32 sectors to a legacy host that does not support devices that large. The Read Capacity commands specify the value returned as the last addressable sector on the device. This means that typically, an application which uses the value returned by that command is going to add 1 to it to get the actual number of blocks on a given device. If the program is not aware of Read Capacity (16), and is not using greater than 32-bit math, then it might report to the user that the total number of sectors on the drive as 0. I don't view this as a huge problem, however. In that case, the legacy driver wouldn't correctly support the capacity of the drive anyway, so providing that driver with a device that is 2 ^ 32 sectors or larger wouldn't make sense from the user perspective.
This commit is contained in:
Chris Hooper
2025-11-16 19:24:30 -08:00
committed by Daniel Markstedt
parent ba713861e8
commit 25718e0887
6 changed files with 33 additions and 28 deletions
Download Patch File Download Diff File Expand all files Collapse all files
cpp/devices/disk_cache.cpp
+8 -8
View File
@@ -20,7 +20,7 @@
#include <cassert>
#include <algorithm>
DiskCache::DiskCache(const string& path, int size, uint32_t blocks, off_t imgoff)
DiskCache::DiskCache(const string& path, int size, uint64_t blocks, off_t imgoff)
: sec_path(path), sec_size(size), sec_blocks(blocks), imgoffset(imgoff)
{
assert(blocks > 0);
@@ -34,19 +34,19 @@ bool DiskCache::Save()
{ return c.disktrk != nullptr && !c.disktrk->Save(sec_path, cache_miss_write_count); });
}
shared_ptr<DiskTrack> DiskCache::GetTrack(uint32_t block)
shared_ptr<DiskTrack> DiskCache::GetTrack(uint64_t block)
{
// Update first
UpdateSerialNumber();
// Calculate track (fixed to 256 sectors/track)
int track = block >> 8;
int64_t track = block >> 8;
// Get track data
return Assign(track);
}
bool DiskCache::ReadSector(span<uint8_t> buf, uint32_t block)
bool DiskCache::ReadSector(span<uint8_t> buf, uint64_t block)
{
shared_ptr<DiskTrack> disktrk = GetTrack(block);
if (disktrk == nullptr) {
@@ -57,7 +57,7 @@ bool DiskCache::ReadSector(span<uint8_t> buf, uint32_t block)
return disktrk->ReadSector(buf, block & 0xff);
}
bool DiskCache::WriteSector(span<const uint8_t> buf, uint32_t block)
bool DiskCache::WriteSector(span<const uint8_t> buf, uint64_t block)
{
shared_ptr<DiskTrack> disktrk = GetTrack(block);
if (disktrk == nullptr) {
@@ -73,7 +73,7 @@ bool DiskCache::WriteSector(span<const uint8_t> buf, uint32_t block)
// Track Assignment
//
//---------------------------------------------------------------------------
shared_ptr<DiskTrack> DiskCache::Assign(int track)
shared_ptr<DiskTrack> DiskCache::Assign(int64_t track)
{
assert(sec_size != 0);
assert(track >= 0);
@@ -143,14 +143,14 @@ shared_ptr<DiskTrack> DiskCache::Assign(int track)
// Load cache
//
//---------------------------------------------------------------------------
bool DiskCache::Load(int index, int track, shared_ptr<DiskTrack> disktrk)
bool DiskCache::Load(int index, int64_t track, shared_ptr<DiskTrack> disktrk)
{
assert(index >= 0 && index < static_cast<int>(cache.size()));
assert(track >= 0);
assert(cache[index].disktrk == nullptr);
// Get the number of sectors on this track
int sectors = sec_blocks - (track << 8);
int64_t sectors = sec_blocks - (track << 8);
assert(sectors > 0);
if (sectors > 0x100) {
sectors = 0x100;