Apple-2-Tools/ciderpress
1
0
Fork 0
mirror of https://github.com/fadden/ciderpress.git synced 2024-11-23 11:33:58 +00:00
Code Issues Projects Releases Wiki Activity
0a317cb0e7
ciderpress/diskimg/CFFA.cpp

592 lines
20 KiB
C++
Raw Normal View History

initial import
2007-03-27 17:47:10 +00:00
/*
* 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.
*/
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 20:56:19 +00:00
/*static*/ DIError DiskFSCFFA::TestImage(DiskImg* pImg,
DiskImg::SectorOrder imageOrder, DiskImg::FSFormat* pFormatFound)
initial import
2007-03-27 17:47:10 +00:00
{
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-04 00:26:53 +00:00
DIError dierr;
long totalBlocks = pImg->GetNumBlocks();
long startBlock, maxBlocks, totalBlocksLeft;
long fsNumBlocks;
Change "nil" to "NULL"
2014-11-18 05:13:13 +00:00
DiskFS* pNewFS = NULL;
DiskImg* pNewImg = NULL;
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-04 00:26:53 +00:00
//bool fiveIs32MB;
assert(totalBlocks > kEarlyVolExpectedSize);
// could be "generic" from an earlier override
if (*pFormatFound != DiskImg::kFormatCFFA4 &&
*pFormatFound != DiskImg::kFormatCFFA8)
{
*pFormatFound = DiskImg::kFormatUnknown;
}
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI("----- BEGIN CFFA SCAN (fmt=%d) -----", *pFormatFound);
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-04 00:26:53 +00:00
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) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFA failed opening sub-volume #1");
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-04 00:26:53 +00:00
goto bail;
}
fsNumBlocks = pNewFS->GetFSNumBlocks();
delete pNewFS;
delete pNewImg;
if (fsNumBlocks != kEarlyVolExpectedSize &&
fsNumBlocks != kEarlyVolExpectedSize-1)
{
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFA found fsNumBlocks=%ld in slot #1", fsNumBlocks);
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-04 00:26:53 +00:00
dierr = kDIErrFilesystemNotFound;
goto bail;
}
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFA found good volume in slot #1");
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-04 00:26:53 +00:00
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) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFA failed opening sub-volume #2");
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-04 00:26:53 +00:00
if (maxBlocks < kEarlyVolExpectedSize)
goto bail;
// otherwise, assume they just didn't format #2, and keep going
} else {
fsNumBlocks = pNewFS->GetFSNumBlocks();
delete pNewFS;
delete pNewImg;
initial import
2007-03-27 17:47:10 +00:00
#if 0
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-04 00:26:53 +00:00
if (fsNumBlocks != kEarlyVolExpectedSize &&
fsNumBlocks != kEarlyVolExpectedSize-1)
{
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFA found fsNumBlocks=%ld in slot #2", fsNumBlocks);
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-04 00:26:53 +00:00
dierr = kDIErrFilesystemNotFound;
goto bail;
}
initial import
2007-03-27 17:47:10 +00:00
#endif
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFA found good volume in slot #2");
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-04 00:26:53 +00:00
}
startBlock += maxBlocks;
totalBlocksLeft -= maxBlocks;
if (totalBlocksLeft == 0) {
*pFormatFound = DiskImg::kFormatCFFA4;
goto bail;
}
/*
* Skip #3 and #4.
*/
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFA skipping over slot #3");
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-04 00:26:53 +00:00
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;
}
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFA skipping over slot #4");
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-04 00:26:53 +00:00
/*
* 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.
*/
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFA assuming odd-sized slot #5");
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-04 00:26:53 +00:00
*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;
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFA failed opening large sub-volume #5");
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-04 00:26:53 +00:00
// 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) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFA WARNING: FSNumBlocks #5 reported blocks=%ld",
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-04 00:26:53 +00:00
fsNumBlocks);
}
if (fsNumBlocks == kEarlyVolExpectedSize-1 ||
fsNumBlocks == kEarlyVolExpectedSize)
{
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFA #5 is a 32MB volume");
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-04 00:26:53 +00:00
// 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
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFA #5 is larger than 32MB");
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-04 00:26:53 +00:00
*pFormatFound = DiskImg::kFormatCFFA4;
goto bail;
} else {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFA #5 was unexpectedly small (%ld blocks)", fsNumBlocks);
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-04 00:26:53 +00:00
// just stop now
*pFormatFound = DiskImg::kFormatCFFA4;
goto bail;
}
startBlock += maxBlocks;
totalBlocksLeft -= maxBlocks;
if (!totalBlocksLeft) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFA got 5 volumes");
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-04 00:26:53 +00:00
*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.
*/
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFA probing 6th slot for 4-vs-8");
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-04 00:26:53 +00:00
/*
* 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;
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFA no vol #6 found at +32MB");
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-04 00:26:53 +00:00
} 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;
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFA no vol #6 found at +1GB");
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-04 00:26:53 +00:00
} else {
foundGig = true;
delete pNewFS;
delete pNewImg;
}
}
dierr = kDIErrNone;
if (!foundSmall && !foundGig) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFA no valid filesystem found in 6th position");
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-04 00:26:53 +00:00
*pFormatFound = DiskImg::kFormatCFFA4;
// don't bother looking for 7 and 8
} else if (foundSmall && foundGig) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFA WARNING: found valid volumes at +32MB *and* +1GB");
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-04 00:26:53 +00:00
// default to 4-partition mode
if (*pFormatFound == DiskImg::kFormatUnknown)
*pFormatFound = DiskImg::kFormatCFFA4;
} else if (foundGig) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFA found 6th volume at +1GB, assuming 4-mode w/GSOS");
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-04 00:26:53 +00:00
if (fsNumBlocks < 2 || fsNumBlocks > kOneGB) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFA WARNING: FSNumBlocks #6 reported as %ld",
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-04 00:26:53 +00:00
fsNumBlocks);
}
*pFormatFound = DiskImg::kFormatCFFA4;
} else if (foundSmall) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFA found 6th volume at +32MB, assuming 8-mode");
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-04 00:26:53 +00:00
if (fsNumBlocks < 2 || fsNumBlocks > kEarlyVolExpectedSize) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFA WARNING: FSNumBlocks #6 reported as %ld",
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-04 00:26:53 +00:00
fsNumBlocks);
}
*pFormatFound = DiskImg::kFormatCFFA8;
} else {
assert(false); // how'd we get here??
}
// done!
initial import
2007-03-27 17:47:10 +00:00
bail:
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI("----- END CFFA SCAN (err=%d format=%d) -----",
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-04 00:26:53 +00:00
dierr, *pFormatFound);
if (dierr == kDIErrNone) {
assert(*pFormatFound != DiskImg::kFormatUnknown);
} else {
*pFormatFound = DiskImg::kFormatUnknown;
}
return dierr;
initial import
2007-03-27 17:47:10 +00:00
}
/*
* 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.
*/
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 20:56:19 +00:00
/*static*/ DIError DiskFSCFFA::OpenSubVolume(DiskImg* pImg, long startBlock,
long numBlocks, bool scanOnly, DiskImg** ppNewImg, DiskFS** ppNewFS)
initial import
2007-03-27 17:47:10 +00:00
{
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-04 00:26:53 +00:00
DIError dierr = kDIErrNone;
Change "nil" to "NULL"
2014-11-18 05:13:13 +00:00
DiskFS* pNewFS = NULL;
DiskImg* pNewImg = NULL;
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-04 00:26:53 +00:00
pNewImg = new DiskImg;
Change "nil" to "NULL"
2014-11-18 05:13:13 +00:00
if (pNewImg == NULL) {
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-04 00:26:53 +00:00
dierr = kDIErrMalloc;
goto bail;
}
dierr = pNewImg->OpenImage(pImg, startBlock, numBlocks);
if (dierr != kDIErrNone) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFASub: OpenImage(%ld,%ld) failed (err=%d)",
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-04 00:26:53 +00:00
startBlock, numBlocks, dierr);
goto bail;
}
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
//LOGI(" +++ CFFASub: new image has ro=%d (parent=%d)",
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-04 00:26:53 +00:00
// pNewImg->GetReadOnly(), pImg->GetReadOnly());
dierr = pNewImg->AnalyzeImage();
if (dierr != kDIErrNone) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFASub: analysis failed (err=%d)", dierr);
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-04 00:26:53 +00:00
goto bail;
}
if (pNewImg->GetFSFormat() == DiskImg::kFormatUnknown ||
pNewImg->GetSectorOrder() == DiskImg::kSectorOrderUnknown)
{
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFASub: unable to identify filesystem at %ld",
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-04 00:26:53 +00:00
startBlock);
dierr = kDIErrUnsupportedFSFmt;
goto bail;
}
/* open a DiskFS for the sub-image */
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFASub (%ld,%ld) analyze succeeded!", startBlock, numBlocks);
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-04 00:26:53 +00:00
pNewFS = pNewImg->OpenAppropriateDiskFS();
Change "nil" to "NULL"
2014-11-18 05:13:13 +00:00
if (pNewFS == NULL) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFASub: OpenAppropriateDiskFS failed");
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-04 00:26:53 +00:00
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) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFASub: error %d reading list of files from disk", dierr);
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-04 00:26:53 +00:00
goto bail;
}
initial import
2007-03-27 17:47:10 +00:00
bail:
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-04 00:26:53 +00:00
if (dierr != kDIErrNone) {
delete pNewFS;
delete pNewImg;
} else {
*ppNewImg = pNewImg;
*ppNewFS = pNewFS;
}
return dierr;
initial import
2007-03-27 17:47:10 +00:00
}
/*
* Check to see if this is a CFFA volume.
*/
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 20:56:19 +00:00
/*static*/ DIError DiskFSCFFA::TestFS(DiskImg* pImg, DiskImg::SectorOrder* pOrder,
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-04 00:26:53 +00:00
DiskImg::FSFormat* pFormat, FSLeniency leniency)
initial import
2007-03-27 17:47:10 +00:00
{
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-04 00:26:53 +00:00
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);
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" FS didn't find valid CFFA");
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-04 00:26:53 +00:00
return kDIErrFilesystemNotFound;
initial import
2007-03-27 17:47:10 +00:00
}
/*
* Prep the CFFA "container" for use.
*/
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 20:56:19 +00:00
DIError DiskFSCFFA::Initialize(void)
initial import
2007-03-27 17:47:10 +00:00
{
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-04 00:26:53 +00:00
DIError dierr = kDIErrNone;
initial import
2007-03-27 17:47:10 +00:00
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI("CFFA initializing (scanForSub=%d)", fScanForSubVolumes);
initial import
2007-03-27 17:47:10 +00:00
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-04 00:26:53 +00:00
/* seems pointless *not* to, but we just do what we're told */
if (fScanForSubVolumes != kScanSubDisabled) {
dierr = FindSubVolumes();
if (dierr != kDIErrNone)
return dierr;
}
initial import
2007-03-27 17:47:10 +00:00
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-04 00:26:53 +00:00
/* blank out the volume usage map */
SetVolumeUsageMap();
initial import
2007-03-27 17:47:10 +00:00
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-04 00:26:53 +00:00
return dierr;
initial import
2007-03-27 17:47:10 +00:00
}
/*
* 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.
*/
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 20:56:19 +00:00
DIError DiskFSCFFA::FindSubVolumes(void)
initial import
2007-03-27 17:47:10 +00:00
{
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-04 00:26:53 +00:00
DIError dierr;
long startBlock, blocksLeft;
startBlock = 0;
blocksLeft = fpImg->GetNumBlocks();
if (fpImg->GetFSFormat() == DiskImg::kFormatCFFA4) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFA opening 4+2 volumes");
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-04 00:26:53 +00:00
dierr = AddVolumeSeries(0, 4, kEarlyVolExpectedSize, /*ref*/startBlock,
/*ref*/blocksLeft);
if (dierr != kDIErrNone)
goto bail;
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFA after first 4, startBlock=%ld blocksLeft=%ld",
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-04 00:26:53 +00:00
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) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFA opening 8 volumes");
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-04 00:26:53 +00:00
dierr = AddVolumeSeries(0, 8, kEarlyVolExpectedSize, /*ref*/startBlock,
/*ref*/blocksLeft);
if (dierr != kDIErrNone)
goto bail;
} else {
assert(false);
return kDIErrInternal;
}
if (blocksLeft != 0) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFA ignoring leftover %ld blocks", blocksLeft);
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-04 00:26:53 +00:00
}
initial import
2007-03-27 17:47:10 +00:00
bail:
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-04 00:26:53 +00:00
return dierr;
initial import
2007-03-27 17:47:10 +00:00
}
/*
* Add a series of equal-sized volumes.
*
* Updates "startBlock" and "totalBlocksLeft".
*/
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 20:56:19 +00:00
DIError DiskFSCFFA::AddVolumeSeries(int start, int count, long blocksPerVolume,
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-04 00:26:53 +00:00
long& startBlock, long& totalBlocksLeft)
initial import
2007-03-27 17:47:10 +00:00
{
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-04 00:26:53 +00:00
DIError dierr = kDIErrNone;
Change "nil" to "NULL"
2014-11-18 05:13:13 +00:00
DiskFS* pNewFS = NULL;
DiskImg* pNewImg = NULL;
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-04 00:26:53 +00:00
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;
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFA failed opening sub-volume %d (not formatted?)", i);
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-04 00:26:53 +00:00
/* create a fake one to represent the partition */
dierr = CreatePlaceholder(startBlock, maxBlocks, NULL, NULL,
&pNewImg, &pNewFS);
if (dierr == kDIErrNone) {
AddSubVolumeToList(pNewImg, pNewFS);
} else {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFA unable to create placeholder (%ld, %ld) (err=%d)",
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-04 00:26:53 +00:00
startBlock, maxBlocks, dierr);
goto bail;
}
} else {
fsNumBlocks = pNewFS->GetFSNumBlocks();
if (fsNumBlocks < 2 || fsNumBlocks > blocksPerVolume) {
Convert WSMG to LOG Mostly a bulk conversion of debug messages, primarily with sed: sed -e 's/\(WMSG[0-9]\)\(.*\)\(\\n"\)/LOGI\2"/' This removes the '\n' from the end of the log messages, and sets them all to "info" severity. We want to prefix each line with file/line and/or a timestamp, so it doesn't make sense to have a partial line, and there's no value in embedding the '\n' in every string.
2014-11-18 21:05:15 +00:00
LOGI(" CFFA WARNING: FSNumBlocks #%d reported as %ld",
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-04 00:26:53 +00:00
i, fsNumBlocks);
}
AddSubVolumeToList(pNewImg, pNewFS);
}
startBlock += maxBlocks;
totalBlocksLeft -= maxBlocks;
if (!totalBlocksLeft)
break; // all done
}
initial import
2007-03-27 17:47:10 +00:00
bail:
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-04 00:26:53 +00:00
return dierr;
initial import
2007-03-27 17:47:10 +00:00
}
Reference in New Issue Copy Permalink