ciderpress/diskimg/Win32BlockIO.h
Andy McFadden adaeb2c6eb Fix warnings
Added explicit casts and class initializers.  The problems were
identified by the VS2019 compiler.
2021-04-24 13:43:04 -07:00

414 lines
15 KiB
C++

/*
* CiderPress
* Copyright (C) 2007 by faddenSoft, LLC. All Rights Reserved.
* See the file LICENSE for distribution terms.
*/
#ifdef _WIN32
/*
* Structures and functions for performing block-level I/O on Win32 logical
* and physical volumes.
*
* Under Win2K/XP this is pretty straightforward: open the volume and
* issue seek and read calls. It's not quite that simple -- reads need to
* be in 512-byte sectors for floppy and hard drives, seeks need to be on
* sector boundaries, and you can't seek from the end, which makes it hard
* to figure out how big the volume is -- but it's palatable.
*
* Under Win95/Win98/WinME, life is more difficult. You need to use the
* Int21h/7305h services to access logical volumes. Of course, those weren't
* available until Win95 OSR2, before which you used Int25h/6000h, but those
* don't work with FAT32 volumes. Access to physical devices requires Int13h,
* which is fine for floppies but requires 16-bit flat thunks for hard drives
* (see Q137176: "DeviceIoControl Int 13h Does Not Support Hard Disks").
*
* If Win98 can't recognize the volume on a floppy, it tries to reacquire
* the volume information every time you ask it to read a sector. This makes
* things *VERY* slow. The solution is to use the physical drive Int13h
* services. These come in two variants, one of which will work on just
* about any machine but only works with floppies. The other will work on
* anything built since about 1996.
*
* Figuring out whether something is or isn't a floppy requires yet
* another call. All things considered it's quite an ordeal. The block I/O
* functions are wrapped up in classes so nobody else has to worry about all
* this mess.
*
* Implementation note: this class is broken down by how the devices are
* opened, e.g. logical, physical, or ASPI address. Breaking it down by device
* type seems more appropriate, but Win98 vs Win2K can require completely
* different approaches (e.g. physical vs. logical for floppy disk, logical
* vs. ASPI for CD-ROM). There is no perfect decomposition.
*
* Summary:
* Win9x/ME physical drive: Int13h (doesn't work for hard drives)
* Win9x/ME logical drive: Int21h/7305h
* Win9x/ME SCSI drive or CD-ROM drive: ASPI
* Win2K/XP physical drive: CreateFile("\\.\PhysicalDriveN")
* Win2K/XP logical drive: CreateFile("\\.\X")
* Win2K/XP SCSI drive or CD-ROM drive: SPTI
*/
#ifndef DISKIMG_WIN32BLOCKIO_H
#define DISKIMG_WIN32BLOCKIO_H
namespace DiskImgLib {
extern bool IsWin9x(void);
/*
* Cache a contiguous set of blocks. This was originally motivated by poor
* write performance, but that problem was largely solved in other ways.
* It's still handy to write an entire track at once under Win98 though.
*
* Only storing continuous runs of blocks makes the cache less useful, but
* much easier to write, and hence less likely to break in unpleasant ways.
*
* This class just manages the blocks. The FlushCache() function in
* Win32LogicalVolume is responsible for actually pushing the writes through.
*
* (I'm not entirely happy with this, especially since it doesn't take into
* account the underlying device block size. This could've been a good place
* to handle the 2048-byte CD-ROM block size, rather than caching it again in
* the CD-ROM handler.)
*/
class CBCache {
public:
CBCache(void) : fFirstBlock(kEmpty), fNumBlocks(0)
{
for (int i = 0; i < kMaxCachedBlocks; i++)
fDirty[i] = false;
}
virtual ~CBCache(void) { Purge(); }
enum { kEmpty = -1 };
// is the block we want in the cache?
bool IsBlockInCache(long blockNum) const;
// read block out of cache (after verifying that it's present)
DIError GetFromCache(long blockNum, void* buf);
// can the cache store this block?
bool IsRoomInCache(long blockNum) const;
// write block to cache (after verifying that it will fit)
DIError PutInCache(long blockNum, const void* buf, bool isDirty);
// are there any dirty blocks in the cache?
bool IsDirty(void) const;
// get start, count, and buffer so we can write the cached data
void GetCachePointer(long* pFirstBlock, int* pNumBlocks, void** pBuf) const;
// clear all the dirty flags
void Scrub(void);
// purge all cache entries (ideally after writing w/help from GetCachePtr)
void Purge(void);
private:
enum {
kMaxCachedBlocks = 18, // one track on 1.4MB floppy
kBlockSize = 512, // must match with Win32LogicalVolume::
};
long fFirstBlock; // set to kEmpty when cache is empty
int fNumBlocks;
bool fDirty[kMaxCachedBlocks];
unsigned char fCache[kMaxCachedBlocks * kBlockSize];
};
/*
* This class encapsulates block access to a logical or physical volume.
*/
class Win32VolumeAccess {
public:
Win32VolumeAccess(void) :
fTotalBlocks(-1),
fpBlockAccess(NULL)
{}
virtual ~Win32VolumeAccess(void) {
if (fpBlockAccess != NULL) {
FlushCache(true);
fpBlockAccess->Close();
}
}
// "deviceName" has the form "X:\" (logical), "81:\" (physical), or
// "ASPI:x:y:z\" (ASPI)
DIError Open(const WCHAR* deviceName, bool readOnly);
// close the device
void Close(void);
// is the device open and working?
bool Ready(void) const { return fpBlockAccess != NULL; }
// return the volume's EOF
long GetTotalBlocks(void) const { return fTotalBlocks; }
// return the block size for this volume (always a power of 2)
int GetBlockSize(void) const { return BlockAccess::kBlockSize; }
// read one or more consecutive blocks
DIError ReadBlocks(long startBlock, short blockCount, void* buf);
// write one or more consecutive blocks
DIError WriteBlocks(long startBlock, short blockCount, const void* buf);
// flush our internal cache
DIError FlushCache(bool purge);
private:
/*
* Abstract base class with some handy functions.
*/
class BlockAccess {
public:
BlockAccess(void) { fIsWin9x = DiskImgLib::IsWin9x(); }
virtual ~BlockAccess(void) {}
typedef struct {
int numCyls;
int numHeads;
int numSectors;
long blockCount; // total #of blocks on this kind of disk
} DiskGeometry;
// generic interfaces
virtual DIError Open(const WCHAR* deviceName, bool readOnly) = 0;
virtual DIError DetectCapacity(long* pNumBlocks) = 0;
virtual DIError ReadBlocks(long startBlock, short blockCount,
void* buf) = 0;
virtual DIError WriteBlocks(long startBlock, short blockCount,
const void* buf) = 0;
virtual DIError Close(void) = 0;
static bool BlockToCylinderHeadSector(long blockNum,
const DiskGeometry* pGeometry, int* pCylinder, int* pHead,
int* pSector, long* pLastBlockOnTrack);
enum {
kNumLogicalVolumes = 26, // A-Z
kBlockSize = 512,
kCDROMSectorSize = 2048,
kMaxFloppyRetries = 3, // retry floppy reads/writes
};
// BIOS floppy disk drive type; doubles here as media type
typedef enum {
kFloppyUnknown = 0,
kFloppy525_360 = 1,
kFloppy525_1200 = 2,
kFloppy35_720 = 3,
kFloppy35_1440 = 4,
kFloppy35_2880 = 5,
kFloppyMax
} FloppyKind;
protected:
static DIError GetFloppyDriveKind(HANDLE handle, int unitNum,
FloppyKind* pKind);
// detect the #of blocks on the volume
static DIError ScanCapacity(BlockAccess* pThis, long* pNumBlocks);
// determine whether a block is readable
static bool CanReadBlock(BlockAccess* pThis, long blockNum);
// try to detect device capacity using SPTI
DIError DetectCapacitySPTI(HANDLE handle,
bool isCDROM, long* pNumBlocks);
static int ReadBlocksInt13h(HANDLE handle, int unitNum,
int cylinder, int head, int sector, short blockCount, void* buf);
static DIError ReadBlocksInt13h(HANDLE handle, int unitNum,
const DiskGeometry* pGeometry, long startBlock, short blockCount,
void* buf);
static int WriteBlocksInt13h(HANDLE handle, int unitNum,
int cylinder, int head, int sector, short blockCount,
const void* buf);
static DIError WriteBlocksInt13h(HANDLE handle, int unitNum,
const DiskGeometry* pGeometry, long startBlock, short blockCount,
const void* buf);
static DIError ReadBlocksInt21h(HANDLE handle, int driveNum,
long startBlock, short blockCount, void* buf);
static DIError WriteBlocksInt21h(HANDLE handle, int driveNum,
long startBlock, short blockCount, const void* buf);
static DIError ReadBlocksWin2K(HANDLE handle,
long startBlock, short blockCount, void* buf);
static DIError WriteBlocksWin2K(HANDLE handle,
long startBlock, short blockCount, const void* buf);
bool fIsWin9x; // Win9x/ME=true, Win2K/XP=false
};
/*
* Access to a logical volume (e.g. "C:\") under Win9x and Win2K/XP.
*/
class LogicalBlockAccess : public BlockAccess {
public:
LogicalBlockAccess(void) : fHandle(NULL), fIsCDROM(false),
fDriveNum(-1), fLastSectorCache(NULL), fLastSectorNum(-1)
{}
virtual ~LogicalBlockAccess(void) {
if (fHandle != NULL) {
//LOGI("HEY: LogicalBlockAccess: forcing close");
Close();
}
delete[] fLastSectorCache;
}
virtual DIError Open(const WCHAR* deviceName, bool readOnly);
virtual DIError DetectCapacity(long* pNumBlocks) {
/* use SCSI length value if at all possible */
DIError dierr;
dierr = DetectCapacitySPTI(fHandle, fIsCDROM, pNumBlocks);
if (fIsCDROM)
return dierr; // SPTI should always work for CD-ROM
if (dierr != kDIErrNone)
return ScanCapacity(this, pNumBlocks); // fall back on scan
else
return dierr;
}
virtual DIError ReadBlocks(long startBlock, short blockCount,
void* buf)
{
if (fIsCDROM)
return ReadBlocksCDROM(fHandle, startBlock, blockCount, buf);
if (fIsWin9x)
return ReadBlocksInt21h(fHandle, fDriveNum, startBlock,
blockCount, buf);
else
return ReadBlocksWin2K(fHandle, startBlock, blockCount, buf);
}
virtual DIError WriteBlocks(long startBlock, short blockCount,
const void* buf)
{
if (fIsCDROM)
return kDIErrWriteProtected;
if (fIsWin9x)
return WriteBlocksInt21h(fHandle, fDriveNum, startBlock,
blockCount, buf);
else
return WriteBlocksWin2K(fHandle, startBlock, blockCount, buf);
}
virtual DIError Close(void);
private:
//DIError DetectCapacitySPTI(long* pNumBlocks);
DIError ReadBlocksCDROM(HANDLE handle,
long startBlock, short numBlocks, void* buf);
// Win2K/XP and Win9x/ME
HANDLE fHandle;
bool fIsCDROM; // set for CD-ROM devices
// Win9x/ME
int fDriveNum; // 1=A, 3=C, etc
// CD-ROM goodies
unsigned char* fLastSectorCache;
long fLastSectorNum;
};
/*
* Access to a physical volume (e.g. 00h or 80h) under Win9x and
* Win2K/XP.
*/
class PhysicalBlockAccess : public BlockAccess {
public:
PhysicalBlockAccess(void) :
fHandle(NULL),
fInt13Unit(-1),
fFloppyKind(kFloppyUnknown)
{}
virtual ~PhysicalBlockAccess(void) {}
virtual DIError Open(const WCHAR* deviceName, bool readOnly);
virtual DIError DetectCapacity(long* pNumBlocks) {
/* try SPTI in case it happens to work */
DIError dierr;
dierr = DetectCapacitySPTI(fHandle, false, pNumBlocks);
if (dierr != kDIErrNone)
return ScanCapacity(this, pNumBlocks);
else
return dierr;
}
virtual DIError ReadBlocks(long startBlock, short blockCount,
void* buf)
{
if (fIsWin9x)
return ReadBlocksInt13h(fHandle, fInt13Unit,
&fGeometry, startBlock, blockCount, buf);
else
return ReadBlocksWin2K(fHandle,
startBlock, blockCount, buf);
}
virtual DIError WriteBlocks(long startBlock, short blockCount,
const void* buf)
{
if (fIsWin9x)
return WriteBlocksInt13h(fHandle, fInt13Unit,
&fGeometry, startBlock, blockCount, buf);
else
return WriteBlocksWin2K(fHandle,
startBlock, blockCount, buf);
}
virtual DIError Close(void);
private:
DIError DetectFloppyGeometry(void);
// Win2K/XP
HANDLE fHandle;
// Win9x/ME
int fInt13Unit; // 00h=floppy #1, 80h=HD#1
FloppyKind fFloppyKind;
DiskGeometry fGeometry;
};
#ifdef WANT_ASPI
/*
* Access to a SCSI volume via the ASPI interface.
*/
class ASPIBlockAccess : public BlockAccess {
public:
ASPIBlockAccess(void) : fpASPI(NULL),
fAdapter(0xff), fTarget(0xff), fLun(0xff), fReadOnly(false),
fLastChunkCache(NULL), fLastChunkNum(-1), fChunkSize(-1)
{}
virtual ~ASPIBlockAccess(void) { delete[] fLastChunkCache; }
virtual DIError Open(const char* deviceName, bool readOnly);
virtual DIError DetectCapacity(long* pNumBlocks);
virtual DIError ReadBlocks(long startBlock, short blockCount,
void* buf);
virtual DIError WriteBlocks(long startBlock, short blockCount,
const void* buf);
virtual DIError Close(void);
private:
int ExtractInt(const char** pStr, int* pResult);
ASPI* fpASPI;
unsigned char fAdapter;
unsigned char fTarget;
unsigned char fLun;
bool fReadOnly;
// block cache
unsigned char* fLastChunkCache;
long fLastChunkNum;
long fChunkSize; // set by DetectCapacity
};
#endif /*WANT_ASPI*/
// write a series of blocks to the volume
DIError DoWriteBlocks(long startBlock, short blockCount, const void* buf)
{
return fpBlockAccess->WriteBlocks(startBlock, blockCount, buf);
}
long fTotalBlocks;
BlockAccess* fpBlockAccess; // really LogicalBA or PhysicalBA
CBCache fBlockCache;
};
}; // namespace DiskImgLib
#endif /*DISKIMG_WIN32BLOCKIO_H*/
#endif /*_WIN32*/