ciderpress/diskimg/VolumeUsage.cpp
Andy McFadden aa3145856c Use types with explicit sizes
Focusing on the diskimg library this time, which deals with a lot of
filesystem structures that have specific widths.

This is still a bit lax in places, e.g. using "long" for lengths.
Should either specify a bit width or use di_off_t.

Also, added "override" keyword where appropriate.

Also, bumped library version to 5.0.0.
2014-11-24 15:57:25 -08:00

270 lines
7.5 KiB
C++

/*
* CiderPress
* Copyright (C) 2007 by faddenSoft, LLC. All Rights Reserved.
* See the file LICENSE for distribution terms.
*/
/*
* Support for the VolumeUsage sub-class in DiskFS.
*/
#include "StdAfx.h"
#include "DiskImgPriv.h"
/*
* Initialize structures for a block-structured disk.
*/
DIError DiskFS::VolumeUsage::Create(long numBlocks)
{
if (numBlocks <= 0 || numBlocks > 32*1024*1024) // 16GB
return kDIErrInvalidArg;
fByBlocks = true;
fNumSectors = -1;
fTotalChunks = numBlocks;
fListSize = numBlocks;
fList = new unsigned char[fListSize];
if (fList == NULL)
return kDIErrMalloc;
memset(fList, 0, fListSize);
return kDIErrNone;
}
/*
* Initialize structures for a track/sector-structured disk.
*/
DIError DiskFS::VolumeUsage::Create(long numTracks, long numSectors)
{
long count = numTracks * numSectors;
if (numTracks <= 0 || count <= 0 || count > 32*1024*1024)
return kDIErrInvalidArg;
fByBlocks = false;
fNumSectors = numSectors;
fTotalChunks = count;
fListSize = count;
fList = new unsigned char[fListSize];
if (fList == NULL)
return kDIErrMalloc;
memset(fList, 0, fListSize);
return kDIErrNone;
}
/*
* Return the state of a particular chunk.
*/
DIError DiskFS::VolumeUsage::GetChunkState(long block, ChunkState* pState) const
{
if (!fByBlocks)
return kDIErrInvalidArg;
return GetChunkStateIdx(block, pState);
}
DIError DiskFS::VolumeUsage::GetChunkState(long track, long sector,
ChunkState* pState) const
{
if (fByBlocks)
return kDIErrInvalidArg;
if (track < 0 || sector < 0 || sector >= fNumSectors)
return kDIErrInvalidArg;
return GetChunkStateIdx(track * fNumSectors + sector, pState);
}
DIError DiskFS::VolumeUsage::GetChunkStateIdx(int idx, ChunkState* pState) const
{
if (fList == NULL || idx < 0 || idx >= fListSize) {
assert(false);
return kDIErrInvalidArg;
}
unsigned char val = fList[idx];
pState->isUsed = (val & kChunkUsedFlag) != 0;
pState->isMarkedUsed = (val & kChunkMarkedUsedFlag) != 0;
pState->purpose = (ChunkPurpose)(val & kChunkPurposeMask);
return kDIErrNone;
}
/*
* Set the state of a particular chunk.
*/
DIError DiskFS::VolumeUsage::SetChunkState(long block, const ChunkState* pState)
{
if (!fByBlocks)
return kDIErrInvalidArg;
return SetChunkStateIdx(block, pState);
}
DIError DiskFS::VolumeUsage::SetChunkState(long track, long sector,
const ChunkState* pState)
{
if (fByBlocks)
return kDIErrInvalidArg;
if (track < 0 || sector < 0 || sector >= fNumSectors)
return kDIErrInvalidArg;
return SetChunkStateIdx(track * fNumSectors + sector, pState);
}
DIError DiskFS::VolumeUsage::SetChunkStateIdx(int idx, const ChunkState* pState)
{
if (fList == NULL || idx < 0 || idx >= fListSize) {
assert(false);
return kDIErrInvalidArg;
}
unsigned char val = 0;
if (pState->isUsed) {
if ((pState->purpose & ~kChunkPurposeMask) != 0) {
assert(false);
return kDIErrInvalidArg;
}
val |= kChunkUsedFlag;
val |= (int)pState->purpose;
}
if (pState->isMarkedUsed)
val |= kChunkMarkedUsedFlag;
fList[idx] = val;
return kDIErrNone;
}
/*
* Count up the #of free chunks.
*/
long DiskFS::VolumeUsage::GetActualFreeChunks(void) const
{
ChunkState cstate; // could probably do this bitwise...
int freeCount = 0;
int funkyCount = 0;
for (int i = 0; i < fTotalChunks; i++) {
if (GetChunkStateIdx(i, &cstate) != kDIErrNone) {
assert(false);
return -1;
}
if (!cstate.isUsed && !cstate.isMarkedUsed)
freeCount++;
if ((!cstate.isUsed && cstate.isMarkedUsed) ||
(cstate.isUsed && !cstate.isMarkedUsed) ||
(cstate.isUsed && cstate.purpose == kChunkPurposeConflict))
{
funkyCount++;
}
}
LOGI(" VU total=%ld free=%d funky=%d",
fTotalChunks, freeCount, funkyCount);
return freeCount;
}
/*
* Convert a ChunkState into a single, hopefully meaningful, character.
*
* Possible states:
* '.' - !inuse, !marked (free space)
* 'X' - !inuse, marked (could be embedded volume)
* '!' - inuse, !marked (danger!)
* '#' - inuse, marked, used by more than one thing
* 'S' - inuse, marked, used by system (directories, volume bit map)
* 'I' - inuse, marked, used by file structure (index block)
* 'F' - inuse, marked, used by file
*/
char DiskFS::VolumeUsage::StateToChar(ChunkState* pState) const
{
if (!pState->isUsed && !pState->isMarkedUsed)
return '.';
if (!pState->isUsed && pState->isMarkedUsed)
return 'X';
if (pState->isUsed && !pState->isMarkedUsed)
return '!';
assert(pState->isUsed && pState->isMarkedUsed);
if (pState->purpose == kChunkPurposeUnknown)
return '?';
if (pState->purpose == kChunkPurposeConflict)
return '#';
if (pState->purpose == kChunkPurposeSystem)
return 'S';
if (pState->purpose == kChunkPurposeVolumeDir)
return 'V';
if (pState->purpose == kChunkPurposeSubdir)
return 'D';
if (pState->purpose == kChunkPurposeUserData)
return 'F';
if (pState->purpose == kChunkPurposeFileStruct)
return 'I';
if (pState->purpose == kChunkPurposeEmbedded)
return 'E';
assert(false);
return '?';
}
/*
* Dump the list.
*/
void DiskFS::VolumeUsage::Dump(void) const
{
#define kMapInit "--------------------------------"
if (fList == NULL) {
LOGI(" VU asked to dump empty list?");
return;
}
LOGI(" VU VolumeUsage dump (%ld free chunks):",
GetActualFreeChunks());
if (fByBlocks) {
ChunkState cstate;
char freemap[32+1] = kMapInit;
int block;
const int kEntriesPerLine = 32; // use 20 to match Copy][+
for (block = 0; block < fTotalChunks; block++) {
if (GetChunkState(block, &cstate) != kDIErrNone) {
assert(false);
return;
}
freemap[block % kEntriesPerLine] = StateToChar(&cstate);
if ((block % kEntriesPerLine) == kEntriesPerLine-1) {
LOGI(" 0x%04x: %s", block-(kEntriesPerLine-1), freemap);
}
}
if ((block % kEntriesPerLine) != 0) {
memset(freemap + (block % kEntriesPerLine), '-',
kEntriesPerLine - (block % kEntriesPerLine));
LOGI(" 0x%04x: %s", block-(kEntriesPerLine-1), freemap);
}
} else {
ChunkState cstate;
char freemap[32+1] = kMapInit;
long numTracks = fTotalChunks / fNumSectors;
int track, sector;
if (fNumSectors > 32) {
LOGI(" VU too many sectors (%ld)", fNumSectors);
return;
}
LOGI(" map 0123456789abcdef");
for (track = 0; track < numTracks; track++) {
for (sector = 0; sector < fNumSectors; sector++) {
if (GetChunkState(track, sector, &cstate) != kDIErrNone) {
assert(false);
return;
}
freemap[sector] = StateToChar(&cstate);
}
LOGI(" %2d: %s", track, freemap);
}
}
}