mirror of
https://github.com/fadden/ciderpress.git
synced 2024-11-26 17:49:21 +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.
592 lines
20 KiB
C++
592 lines
20 KiB
C++
/*
|
|
* CiderPress
|
|
* Copyright (C) 2007 by faddenSoft, LLC. All Rights Reserved.
|
|
* See the file LICENSE for distribution terms.
|
|
*/
|
|
/*
|
|
* The "CFFA" DiskFS is a container class for multiple ProDOS and HFS volumes.
|
|
*
|
|
* The CFFA card doesn't have any RAM, so the author used a fixed partitioning
|
|
* scheme. You get 4 or 8 volumes -- depending on which firmware you jumper
|
|
* in -- at 32MB each. CF cards usually hold less than you would expect, so
|
|
* a 64MB card would have one 32MB volume and one less-than-32MB volume.
|
|
*
|
|
* With Dave's GS/OS driver, you get an extra drive or two at the end, at up
|
|
* to 1GB each. The driver only works in 4-volume mode.
|
|
*
|
|
* There is no magic CFFA block at the front, so it looks like a plain
|
|
* ProDOS or HFS volume. If the size is less than 32MB -- meaning there's
|
|
* only one volume -- we don't need to take an interest in the file,
|
|
* because the regular filesystem goodies will handle it just fine. If it's
|
|
* more than 32MB, we need to create a structure in which multiple volumes
|
|
* reside.
|
|
*
|
|
* The trick is finding all the volumes. The first four are easy. The
|
|
* fifth one is either another 32MB volume (if you're in 8-volume mode)
|
|
* or a volume whose size is somewhere between the amount of space left
|
|
* and 1GB. Not an issue until we get to CF cards > 128MB. We have to
|
|
* rely on the CFFA card making volumes as large as it can.
|
|
*
|
|
* I think it's reasonable to require that the first volume be either ProDOS
|
|
* or HFS. That way we don't go digging through large non-CFFA files when
|
|
* auto-probing.
|
|
*/
|
|
#include "StdAfx.h"
|
|
#include "DiskImgPriv.h"
|
|
|
|
/*
|
|
* Figure out if this is a CFFA volume, and if so, whether it was formatted
|
|
* in 4-partition or 8-partition mode.
|
|
*
|
|
* The "imageOrder" parameter has no use here, because (in the current
|
|
* version) embedded parent volumes are implicitly ProDOS-ordered.
|
|
*
|
|
* "*pFormatFound" should be either a CFFA format or "unknown" on entry.
|
|
* If it's not "unknown", we will look for the specified format first.
|
|
* Otherwise, we look for 4-partition then 8-partition. The first one
|
|
* we find successfully is returned.
|
|
*
|
|
* Ideally we'd have some way to express ambiguity here, so that we could
|
|
* force the "disk format verification" dialog to come up. No such
|
|
* mechanism exists, and for now it doesn't seem worthwhile to add one.
|
|
*/
|
|
/*static*/ DIError DiskFSCFFA::TestImage(DiskImg* pImg,
|
|
DiskImg::SectorOrder imageOrder, DiskImg::FSFormat* pFormatFound)
|
|
{
|
|
DIError dierr;
|
|
long totalBlocks = pImg->GetNumBlocks();
|
|
long startBlock, maxBlocks, totalBlocksLeft;
|
|
long fsNumBlocks;
|
|
DiskFS* pNewFS = NULL;
|
|
DiskImg* pNewImg = NULL;
|
|
//bool fiveIs32MB;
|
|
|
|
assert(totalBlocks > kEarlyVolExpectedSize);
|
|
|
|
// could be "generic" from an earlier override
|
|
if (*pFormatFound != DiskImg::kFormatCFFA4 &&
|
|
*pFormatFound != DiskImg::kFormatCFFA8)
|
|
{
|
|
*pFormatFound = DiskImg::kFormatUnknown;
|
|
}
|
|
|
|
LOGI("----- BEGIN CFFA SCAN (fmt=%d) -----", *pFormatFound);
|
|
|
|
startBlock = 0;
|
|
totalBlocksLeft = totalBlocks;
|
|
|
|
/*
|
|
* Look for a 32MB ProDOS or HFS volume in the first slot. If we
|
|
* don't find this, it's probably not CFFA. It's possible they just
|
|
* didn't format the first one, but that seems unlikely, and it's not
|
|
* unreasonable to insist that they format the first partition.
|
|
*/
|
|
maxBlocks = totalBlocksLeft;
|
|
if (maxBlocks > kEarlyVolExpectedSize)
|
|
maxBlocks = kEarlyVolExpectedSize;
|
|
|
|
dierr = OpenSubVolume(pImg, startBlock, maxBlocks, true,
|
|
&pNewImg, &pNewFS);
|
|
if (dierr != kDIErrNone) {
|
|
LOGI(" CFFA failed opening sub-volume #1");
|
|
goto bail;
|
|
}
|
|
fsNumBlocks = pNewFS->GetFSNumBlocks();
|
|
delete pNewFS;
|
|
delete pNewImg;
|
|
if (fsNumBlocks != kEarlyVolExpectedSize &&
|
|
fsNumBlocks != kEarlyVolExpectedSize-1)
|
|
{
|
|
LOGI(" CFFA found fsNumBlocks=%ld in slot #1", fsNumBlocks);
|
|
dierr = kDIErrFilesystemNotFound;
|
|
goto bail;
|
|
}
|
|
LOGI(" CFFA found good volume in slot #1");
|
|
|
|
startBlock += maxBlocks;
|
|
totalBlocksLeft -= maxBlocks;
|
|
assert(totalBlocksLeft > 0);
|
|
|
|
/*
|
|
* Look for a ProDOS or HFS volume <= 32MB in the second slot. If
|
|
* we don't find something here, and this is a 64MB card, then there's
|
|
* no advantage to using CFFA (in fact, the single-volume handling may
|
|
* be more convenient). If there's at least another 32MB, we continue
|
|
* looking.
|
|
*/
|
|
maxBlocks = totalBlocksLeft;
|
|
if (maxBlocks > kEarlyVolExpectedSize)
|
|
maxBlocks = kEarlyVolExpectedSize;
|
|
|
|
dierr = OpenSubVolume(pImg, startBlock, maxBlocks, true,
|
|
&pNewImg, &pNewFS);
|
|
if (dierr != kDIErrNone) {
|
|
LOGI(" CFFA failed opening sub-volume #2");
|
|
if (maxBlocks < kEarlyVolExpectedSize)
|
|
goto bail;
|
|
// otherwise, assume they just didn't format #2, and keep going
|
|
} else {
|
|
fsNumBlocks = pNewFS->GetFSNumBlocks();
|
|
delete pNewFS;
|
|
delete pNewImg;
|
|
#if 0
|
|
if (fsNumBlocks != kEarlyVolExpectedSize &&
|
|
fsNumBlocks != kEarlyVolExpectedSize-1)
|
|
{
|
|
LOGI(" CFFA found fsNumBlocks=%ld in slot #2", fsNumBlocks);
|
|
dierr = kDIErrFilesystemNotFound;
|
|
goto bail;
|
|
}
|
|
#endif
|
|
LOGI(" CFFA found good volume in slot #2");
|
|
}
|
|
|
|
startBlock += maxBlocks;
|
|
totalBlocksLeft -= maxBlocks;
|
|
if (totalBlocksLeft == 0) {
|
|
*pFormatFound = DiskImg::kFormatCFFA4;
|
|
goto bail;
|
|
}
|
|
|
|
/*
|
|
* Skip #3 and #4.
|
|
*/
|
|
LOGI(" CFFA skipping over slot #3");
|
|
maxBlocks = kEarlyVolExpectedSize*2;
|
|
if (maxBlocks > totalBlocksLeft)
|
|
maxBlocks = totalBlocksLeft;
|
|
startBlock += maxBlocks;
|
|
totalBlocksLeft -= maxBlocks;
|
|
if (totalBlocksLeft == 0) {
|
|
// no more partitions to find; we're done
|
|
*pFormatFound = DiskImg::kFormatCFFA4;
|
|
goto bail;
|
|
}
|
|
LOGI(" CFFA skipping over slot #4");
|
|
|
|
/*
|
|
* Partition #5. We know where it starts, but not how large it is.
|
|
* Could be 32MB, could be 1GB, could be anything between.
|
|
*
|
|
* CF cards come in power-of-two sizes -- 128MB, 256MB, etc. -- but
|
|
* we don't want to make assumptions here. It's possible we're
|
|
* looking at an odd-sized image file that some clever person is
|
|
* expecting to access with CiderPress.
|
|
*/
|
|
maxBlocks = totalBlocksLeft;
|
|
if (maxBlocks > kOneGB)
|
|
maxBlocks = kOneGB;
|
|
if (maxBlocks <= kEarlyVolExpectedSize) {
|
|
/*
|
|
* Only enough room for one <= 32MB volume. Not expected for a
|
|
* real CFFA card, unless they come in 160MB sizes.
|
|
*
|
|
* Treat it like 4-partition; it'll look like somebody slapped a
|
|
* 32MB volume into the first 1GB area.
|
|
*/
|
|
LOGI(" CFFA assuming odd-sized slot #5");
|
|
*pFormatFound = DiskImg::kFormatCFFA4;
|
|
goto bail;
|
|
}
|
|
|
|
/*
|
|
* We could be looking at a 32MB ProDOS partition, 32MB HFS partition,
|
|
* or an up to 1GB HFS partition. We have to specify the size in
|
|
* the OpenSubVolume request, which means trying it both ways and
|
|
* finding a match from GetFSNumBlocks(). Complicating matters is
|
|
* truncation (ProDOS max 65535, not 65536) and round-off (not sure
|
|
* how HFS deals with left-over blocks).
|
|
*
|
|
* Start with <= 1GB.
|
|
*/
|
|
dierr = OpenSubVolume(pImg, startBlock, maxBlocks, true,
|
|
&pNewImg, &pNewFS);
|
|
if (dierr != kDIErrNone) {
|
|
if (dierr == kDIErrCancelled)
|
|
goto bail;
|
|
LOGI(" CFFA failed opening large sub-volume #5");
|
|
// if we can't get #5, don't bother looking for #6
|
|
// (we could try anyway, but it's easier to just skip it)
|
|
dierr = kDIErrNone;
|
|
*pFormatFound = DiskImg::kFormatCFFA4;
|
|
goto bail;
|
|
}
|
|
|
|
fsNumBlocks = pNewFS->GetFSNumBlocks();
|
|
delete pNewFS;
|
|
delete pNewImg;
|
|
if (fsNumBlocks < 2 || fsNumBlocks > maxBlocks) {
|
|
LOGI(" CFFA WARNING: FSNumBlocks #5 reported blocks=%ld",
|
|
fsNumBlocks);
|
|
}
|
|
if (fsNumBlocks == kEarlyVolExpectedSize-1 ||
|
|
fsNumBlocks == kEarlyVolExpectedSize)
|
|
{
|
|
LOGI(" CFFA #5 is a 32MB volume");
|
|
// tells us nothing -- could still be 4 or 8, so we keep going
|
|
maxBlocks = kEarlyVolExpectedSize;
|
|
} else if (fsNumBlocks > kEarlyVolExpectedSize) {
|
|
// must be a GS/OS 1GB area
|
|
LOGI(" CFFA #5 is larger than 32MB");
|
|
*pFormatFound = DiskImg::kFormatCFFA4;
|
|
goto bail;
|
|
} else {
|
|
LOGI(" CFFA #5 was unexpectedly small (%ld blocks)", fsNumBlocks);
|
|
// just stop now
|
|
*pFormatFound = DiskImg::kFormatCFFA4;
|
|
goto bail;
|
|
}
|
|
|
|
startBlock += maxBlocks;
|
|
totalBlocksLeft -= maxBlocks;
|
|
|
|
if (!totalBlocksLeft) {
|
|
LOGI(" CFFA got 5 volumes");
|
|
*pFormatFound = DiskImg::kFormatCFFA4;
|
|
goto bail;
|
|
}
|
|
|
|
/*
|
|
* Various possibilities for slots 5 and up:
|
|
* A. Card in 4-partition mode. 5th partition isn't formatted. Don't
|
|
* bother looking for 6th. [already handled]
|
|
* B. Card in 4-partition mode. 5th partition is >32MB HFS. 6th
|
|
* partition will be at +1GB. [already handled]
|
|
* C. Card in 4-partition mode. 5th partition is 32MB ProDOS. 6th
|
|
* partition will be at +1GB.
|
|
* D. Card in 8-partition mode. 5th partition is 32MB HFS. 6th
|
|
* partition will be at +32MB.
|
|
* E. Card in 8-partition mode. 5th partition is 32MB ProDOS. 6th
|
|
* partition will be at +32MB.
|
|
*
|
|
* I'm ignoring D on the off chance somebody could create a 32MB HFS
|
|
* partition in the 1GB space. D and E are handled alike.
|
|
*
|
|
* The difference between C and D/E can *usually* be determined by
|
|
* opening up a 6th partition in the two expected locations.
|
|
*/
|
|
LOGI(" CFFA probing 6th slot for 4-vs-8");
|
|
/*
|
|
* Look in two different places. If we find something at the
|
|
* +32MB mark, assume it's in "8 mode". If we find something at
|
|
* the +1GB mark, assume it's in "4 + GS/OS mode". If both exist
|
|
* we have a problem.
|
|
*/
|
|
bool foundSmall, foundGig;
|
|
|
|
foundSmall = false;
|
|
maxBlocks = totalBlocksLeft;
|
|
if (maxBlocks > kEarlyVolExpectedSize)
|
|
maxBlocks = kEarlyVolExpectedSize;
|
|
dierr = OpenSubVolume(pImg, startBlock + kEarlyVolExpectedSize,
|
|
maxBlocks, true, &pNewImg, &pNewFS);
|
|
if (dierr != kDIErrNone) {
|
|
if (dierr == kDIErrCancelled)
|
|
goto bail;
|
|
LOGI(" CFFA no vol #6 found at +32MB");
|
|
} else {
|
|
foundSmall = true;
|
|
delete pNewFS;
|
|
delete pNewImg;
|
|
}
|
|
|
|
foundGig = false;
|
|
// no need to look if we don't have at least 1GB left!
|
|
if (totalBlocksLeft >= kOneGB) {
|
|
maxBlocks = totalBlocksLeft;
|
|
if (maxBlocks > kOneGB)
|
|
maxBlocks = kOneGB;
|
|
dierr = OpenSubVolume(pImg, startBlock + kOneGB,
|
|
maxBlocks, true, &pNewImg, &pNewFS);
|
|
if (dierr != kDIErrNone) {
|
|
if (dierr == kDIErrCancelled)
|
|
goto bail;
|
|
LOGI(" CFFA no vol #6 found at +1GB");
|
|
} else {
|
|
foundGig = true;
|
|
delete pNewFS;
|
|
delete pNewImg;
|
|
}
|
|
}
|
|
|
|
dierr = kDIErrNone;
|
|
|
|
if (!foundSmall && !foundGig) {
|
|
LOGI(" CFFA no valid filesystem found in 6th position");
|
|
*pFormatFound = DiskImg::kFormatCFFA4;
|
|
// don't bother looking for 7 and 8
|
|
} else if (foundSmall && foundGig) {
|
|
LOGI(" CFFA WARNING: found valid volumes at +32MB *and* +1GB");
|
|
// default to 4-partition mode
|
|
if (*pFormatFound == DiskImg::kFormatUnknown)
|
|
*pFormatFound = DiskImg::kFormatCFFA4;
|
|
} else if (foundGig) {
|
|
LOGI(" CFFA found 6th volume at +1GB, assuming 4-mode w/GSOS");
|
|
if (fsNumBlocks < 2 || fsNumBlocks > kOneGB) {
|
|
LOGI(" CFFA WARNING: FSNumBlocks #6 reported as %ld",
|
|
fsNumBlocks);
|
|
}
|
|
*pFormatFound = DiskImg::kFormatCFFA4;
|
|
} else if (foundSmall) {
|
|
LOGI(" CFFA found 6th volume at +32MB, assuming 8-mode");
|
|
if (fsNumBlocks < 2 || fsNumBlocks > kEarlyVolExpectedSize) {
|
|
LOGI(" CFFA WARNING: FSNumBlocks #6 reported as %ld",
|
|
fsNumBlocks);
|
|
}
|
|
*pFormatFound = DiskImg::kFormatCFFA8;
|
|
} else {
|
|
assert(false); // how'd we get here??
|
|
}
|
|
|
|
// done!
|
|
|
|
bail:
|
|
LOGI("----- END CFFA SCAN (err=%d format=%d) -----",
|
|
dierr, *pFormatFound);
|
|
if (dierr == kDIErrNone) {
|
|
assert(*pFormatFound != DiskImg::kFormatUnknown);
|
|
} else {
|
|
*pFormatFound = DiskImg::kFormatUnknown;
|
|
}
|
|
return dierr;
|
|
}
|
|
|
|
|
|
/*
|
|
* Open up a sub-volume.
|
|
*
|
|
* If "scanOnly" is set, the full DiskFS initialization isn't performed.
|
|
* We just do enough to get the volume size info.
|
|
*/
|
|
/*static*/ DIError DiskFSCFFA::OpenSubVolume(DiskImg* pImg, long startBlock,
|
|
long numBlocks, bool scanOnly, DiskImg** ppNewImg, DiskFS** ppNewFS)
|
|
{
|
|
DIError dierr = kDIErrNone;
|
|
DiskFS* pNewFS = NULL;
|
|
DiskImg* pNewImg = NULL;
|
|
|
|
pNewImg = new DiskImg;
|
|
if (pNewImg == NULL) {
|
|
dierr = kDIErrMalloc;
|
|
goto bail;
|
|
}
|
|
|
|
dierr = pNewImg->OpenImage(pImg, startBlock, numBlocks);
|
|
if (dierr != kDIErrNone) {
|
|
LOGI(" CFFASub: OpenImage(%ld,%ld) failed (err=%d)",
|
|
startBlock, numBlocks, dierr);
|
|
goto bail;
|
|
}
|
|
//LOGI(" +++ CFFASub: new image has ro=%d (parent=%d)",
|
|
// pNewImg->GetReadOnly(), pImg->GetReadOnly());
|
|
|
|
dierr = pNewImg->AnalyzeImage();
|
|
if (dierr != kDIErrNone) {
|
|
LOGI(" CFFASub: analysis failed (err=%d)", dierr);
|
|
goto bail;
|
|
}
|
|
|
|
if (pNewImg->GetFSFormat() == DiskImg::kFormatUnknown ||
|
|
pNewImg->GetSectorOrder() == DiskImg::kSectorOrderUnknown)
|
|
{
|
|
LOGI(" CFFASub: unable to identify filesystem at %ld",
|
|
startBlock);
|
|
dierr = kDIErrUnsupportedFSFmt;
|
|
goto bail;
|
|
}
|
|
|
|
/* open a DiskFS for the sub-image */
|
|
LOGI(" CFFASub (%ld,%ld) analyze succeeded!", startBlock, numBlocks);
|
|
pNewFS = pNewImg->OpenAppropriateDiskFS();
|
|
if (pNewFS == NULL) {
|
|
LOGI(" CFFASub: OpenAppropriateDiskFS failed");
|
|
dierr = kDIErrUnsupportedFSFmt;
|
|
goto bail;
|
|
}
|
|
|
|
/* we encapsulate arbitrary stuff, so encourage child to scan */
|
|
pNewFS->SetScanForSubVolumes(kScanSubEnabled);
|
|
|
|
/*
|
|
* Load the files from the sub-image. When doing our initial tests,
|
|
* or when loading data for the volume copier, we don't want to dig
|
|
* into our sub-volumes, just figure out what they are and where.
|
|
*/
|
|
InitMode initMode;
|
|
if (scanOnly)
|
|
initMode = kInitHeaderOnly;
|
|
else
|
|
initMode = kInitFull;
|
|
dierr = pNewFS->Initialize(pNewImg, initMode);
|
|
if (dierr != kDIErrNone) {
|
|
LOGI(" CFFASub: error %d reading list of files from disk", dierr);
|
|
goto bail;
|
|
}
|
|
|
|
bail:
|
|
if (dierr != kDIErrNone) {
|
|
delete pNewFS;
|
|
delete pNewImg;
|
|
} else {
|
|
*ppNewImg = pNewImg;
|
|
*ppNewFS = pNewFS;
|
|
}
|
|
return dierr;
|
|
}
|
|
|
|
/*
|
|
* Check to see if this is a CFFA volume.
|
|
*/
|
|
/*static*/ DIError DiskFSCFFA::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder,
|
|
DiskImg::FSFormat* pFormat, FSLeniency leniency)
|
|
{
|
|
if (pImg->GetNumBlocks() < kMinInterestingBlocks)
|
|
return kDIErrFilesystemNotFound;
|
|
if (pImg->GetIsEmbedded()) // don't look for CFFA inside CFFA!
|
|
return kDIErrFilesystemNotFound;
|
|
|
|
/* assume ProDOS -- shouldn't matter, since it's embedded */
|
|
if (TestImage(pImg, DiskImg::kSectorOrderProDOS, pFormat) == kDIErrNone) {
|
|
assert(*pFormat == DiskImg::kFormatCFFA4 ||
|
|
*pFormat == DiskImg::kFormatCFFA8);
|
|
*pOrder = DiskImg::kSectorOrderProDOS;
|
|
return kDIErrNone;
|
|
}
|
|
|
|
// make sure we didn't tamper with it
|
|
assert(*pFormat == DiskImg::kFormatUnknown);
|
|
|
|
LOGI(" FS didn't find valid CFFA");
|
|
return kDIErrFilesystemNotFound;
|
|
}
|
|
|
|
|
|
/*
|
|
* Prep the CFFA "container" for use.
|
|
*/
|
|
DIError DiskFSCFFA::Initialize(void)
|
|
{
|
|
DIError dierr = kDIErrNone;
|
|
|
|
LOGI("CFFA initializing (scanForSub=%d)", fScanForSubVolumes);
|
|
|
|
/* seems pointless *not* to, but we just do what we're told */
|
|
if (fScanForSubVolumes != kScanSubDisabled) {
|
|
dierr = FindSubVolumes();
|
|
if (dierr != kDIErrNone)
|
|
return dierr;
|
|
}
|
|
|
|
/* blank out the volume usage map */
|
|
SetVolumeUsageMap();
|
|
|
|
return dierr;
|
|
}
|
|
|
|
|
|
/*
|
|
* Find the various sub-volumes and open them.
|
|
*
|
|
* We don't handle the volume specially unless it's at least 32MB, which
|
|
* means there are at least 2 partitions.
|
|
*/
|
|
DIError DiskFSCFFA::FindSubVolumes(void)
|
|
{
|
|
DIError dierr;
|
|
long startBlock, blocksLeft;
|
|
|
|
startBlock = 0;
|
|
blocksLeft = fpImg->GetNumBlocks();
|
|
|
|
if (fpImg->GetFSFormat() == DiskImg::kFormatCFFA4) {
|
|
LOGI(" CFFA opening 4+2 volumes");
|
|
dierr = AddVolumeSeries(0, 4, kEarlyVolExpectedSize, /*ref*/startBlock,
|
|
/*ref*/blocksLeft);
|
|
if (dierr != kDIErrNone)
|
|
goto bail;
|
|
|
|
LOGI(" CFFA after first 4, startBlock=%ld blocksLeft=%ld",
|
|
startBlock, blocksLeft);
|
|
if (blocksLeft > 0) {
|
|
dierr = AddVolumeSeries(4, 2, kOneGB, /*ref*/startBlock,
|
|
/*ref*/blocksLeft);
|
|
if (dierr != kDIErrNone)
|
|
goto bail;
|
|
}
|
|
} else if (fpImg->GetFSFormat() == DiskImg::kFormatCFFA8) {
|
|
LOGI(" CFFA opening 8 volumes");
|
|
dierr = AddVolumeSeries(0, 8, kEarlyVolExpectedSize, /*ref*/startBlock,
|
|
/*ref*/blocksLeft);
|
|
if (dierr != kDIErrNone)
|
|
goto bail;
|
|
} else {
|
|
assert(false);
|
|
return kDIErrInternal;
|
|
}
|
|
|
|
if (blocksLeft != 0) {
|
|
LOGI(" CFFA ignoring leftover %ld blocks", blocksLeft);
|
|
}
|
|
|
|
bail:
|
|
return dierr;
|
|
}
|
|
|
|
/*
|
|
* Add a series of equal-sized volumes.
|
|
*
|
|
* Updates "startBlock" and "totalBlocksLeft".
|
|
*/
|
|
DIError DiskFSCFFA::AddVolumeSeries(int start, int count, long blocksPerVolume,
|
|
long& startBlock, long& totalBlocksLeft)
|
|
{
|
|
DIError dierr = kDIErrNone;
|
|
DiskFS* pNewFS = NULL;
|
|
DiskImg* pNewImg = NULL;
|
|
long maxBlocks, fsNumBlocks;
|
|
bool scanOnly = false;
|
|
|
|
/* used by volume copier, to avoid deep scan */
|
|
if (GetScanForSubVolumes() == kScanSubContainerOnly)
|
|
scanOnly = true;
|
|
|
|
for (int i = start; i < start+count; i++) {
|
|
maxBlocks = blocksPerVolume;
|
|
if (maxBlocks > totalBlocksLeft)
|
|
maxBlocks = totalBlocksLeft;
|
|
|
|
dierr = OpenSubVolume(fpImg, startBlock, maxBlocks, scanOnly,
|
|
&pNewImg, &pNewFS);
|
|
if (dierr != kDIErrNone) {
|
|
if (dierr == kDIErrCancelled)
|
|
goto bail;
|
|
LOGI(" CFFA failed opening sub-volume %d (not formatted?)", i);
|
|
/* create a fake one to represent the partition */
|
|
dierr = CreatePlaceholder(startBlock, maxBlocks, NULL, NULL,
|
|
&pNewImg, &pNewFS);
|
|
if (dierr == kDIErrNone) {
|
|
AddSubVolumeToList(pNewImg, pNewFS);
|
|
} else {
|
|
LOGI(" CFFA unable to create placeholder (%ld, %ld) (err=%d)",
|
|
startBlock, maxBlocks, dierr);
|
|
goto bail;
|
|
}
|
|
} else {
|
|
fsNumBlocks = pNewFS->GetFSNumBlocks();
|
|
if (fsNumBlocks < 2 || fsNumBlocks > blocksPerVolume) {
|
|
LOGI(" CFFA WARNING: FSNumBlocks #%d reported as %ld",
|
|
i, fsNumBlocks);
|
|
}
|
|
AddSubVolumeToList(pNewImg, pNewFS);
|
|
}
|
|
|
|
startBlock += maxBlocks;
|
|
totalBlocksLeft -= maxBlocks;
|
|
if (!totalBlocksLeft)
|
|
break; // all done
|
|
}
|
|
|
|
bail:
|
|
return dierr;
|
|
}
|