mirror of
https://github.com/fadden/ciderpress.git
synced 2024-10-13 07:23:48 +00:00
aa3145856c
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.
270 lines
7.5 KiB
C++
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);
|
|
}
|
|
}
|
|
}
|