ciderpress/diskimg/VolumeUsage.cpp
Andy McFadden 63b9996009 Normalize indentation and EOL
This updates all source files to use spaces instead of tabs for
indentation.  It also normalizes the end-of-line markers to be
Windows-style CRLF, and ensures that all files end with EOL.

No substantive changes were made; "diff -w" is empty.
2014-11-03 16:26:53 -08:00

279 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 == nil)
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 == nil)
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 == nil || 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 == nil || 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++;
}
}
WMSG3(" VU total=%ld free=%d funky=%d\n",
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
*/
inline 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 == nil) {
WMSG0(" VU asked to dump empty list?\n");
return;
}
WMSG1(" VU VolumeUsage dump (%ld free chunks):\n",
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) {
WMSG2(" 0x%04x: %s\n", block-(kEntriesPerLine-1), freemap);
}
}
if ((block % kEntriesPerLine) != 0) {
memset(freemap + (block % kEntriesPerLine), '-',
kEntriesPerLine - (block % kEntriesPerLine));
WMSG2(" 0x%04x: %s\n", block-(kEntriesPerLine-1), freemap);
}
} else {
ChunkState cstate;
char freemap[32+1] = kMapInit;
long numTracks = fTotalChunks / fNumSectors;
int track, sector;
if (fNumSectors > 32) {
WMSG1(" VU too many sectors (%ld)\n", fNumSectors);
return;
}
WMSG0(" map 0123456789abcdef\n");
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);
}
WMSG2(" %2d: %s\n", track, freemap);
}
}
}