void CondInfoPop( // POP COND_INFO STACK
void )
{
COND_STK* stk = PstkPopElement( &stack_cond_blks );
stk = stk;
_Dump( stk, "POP" );
}
std::wostream& touchmind::model::node::NodeModel::DumpAll(std::wostream& out)
{
out << "NodeModel::DumpAll start <<" << std::endl;
_Dump(out, 0, shared_from_this());
out << "NodeModel::DumpAll end >>" << std::endl;
return out;
}
void touchmind::model::node::NodeModel::_Dump(std::wostream &out, int indent,
const std::shared_ptr<touchmind::model::node::NodeModel> &node) {
_Indent(out, indent);
node->Dump(out);
out << std::endl;
for (size_t i = 0; i < node->GetActualChildrenCount(); ++i) {
auto child = node->GetChild(i);
_Dump(out, indent + 1, child);
}
}
void CondInfoPop( // POP COND_INFO STACK
void )
{
#ifndef NDEBUG
COND_STK* stk = PstkPopElement( &stack_cond_blks );
_Dump( stk, "POP" );
#else
PstkPopElement( &stack_cond_blks );
#endif
}
static void callBackFalse( // CALL-BACK: start of false block
void* data ) // - COND_STK entry
{
COND_STK* info = data; // - COND_STK entry
SE* posn; // - last position
posn = info->posn_last;
info->posn_false = callBackCurrent( info );
FstabSetSvSe( posn );
_Dump( info, "CallBack(false)" );
}
static void callBackTrue( // CALL-BACK: start of true block
void* data ) // - COND_STK entry
{
COND_STK* info = data; // - COND_STK entry
SE* posn; // - current position
posn = callBackCurrent( info );
info->posn_true = posn;
info->posn_false = posn;
_Dump( info, "CallBack(true)" );
}
status_t
CDDBLookup::Lookup(CDDBServer& server, const dev_t device, bool dumpOnly,
bool verbose)
{
scsi_toc_toc* toc = (scsi_toc_toc*)malloc(kMaxTocSize);
if (toc == NULL)
return B_NO_MEMORY;
uint32 cddbID;
if (!_ReadTOC(device, &cddbID, toc)) {
free(toc);
fprintf(stderr, "Skipping device with id %" B_PRId32 ".\n", device);
return B_BAD_TYPE;
}
printf("Looking up CD with CDDB Id %08" B_PRIx32 ".\n", cddbID);
BObjectList<QueryResponseData> queryResponses(10, true);
status_t result = server.Query(cddbID, toc, queryResponses);
if (result != B_OK) {
fprintf(stderr, "Error when querying CD: %s\n", strerror(result));
free(toc);
return result;
}
free(toc);
const QueryResponseData* diskData = _SelectResult(queryResponses);
if (diskData == NULL) {
fprintf(stderr, "Could not find any CD entries in query response.\n");
return B_BAD_INDEX;
}
ReadResponseData readResponse;
result = server.Read(*diskData, readResponse, verbose);
if (result != B_OK) {
fprintf(stderr, "Could not read detailed CD entry from server: %s\n",
strerror(result));
return result;
}
if (dumpOnly)
_Dump(readResponse);
if (!dumpOnly) {
result = _WriteCDData(device, *diskData, readResponse);
if (result == B_OK)
printf("CD data saved.\n");
else
fprintf(stderr, "Error writing CD data: %s\n", strerror(result));
}
return B_OK;
}
static void callBackNewCtorEnd( // CALL-BACK: end of new ctor
void* data ) // - COND_STK entry
{
COND_STK* cond = data; // - COND_STK entry
_Dump( cond, "CallBack(END-NEW_CTOR)" );
if( cond->posn_true == FstabActualPosn() ) {
FstabRemove();
cond->mask_set = 0;
cond->mask_clr = NOT_BITARR_MASK( 0 );
}
callBackFini( cond );
};
void CondInfoPush( // PUSH COND_INFO STACK
FN_CTL* fctl ) // - function control
{
COND_STK* stk = CarveAlloc( carveInfo );
stk->offset = FnCtlCondFlagNext( fctl );
stk->handle_set = NULL;
stk->handle_clr = NULL;
stk->mask_set = 0;
stk->mask_clr = NOT_BITARR_MASK( 0 );
stk->posn_last = 0;
stk->posn_true = 0;
stk->posn_false = 0;
PstkPush( &stack_cond_blks, stk );
_Dump( stk, "PUSH" );
}
status_t
CDDBLookup::Dump(CDDBServer& server, const char* category, const char* cddbID,
bool verbose)
{
ReadResponseData readResponse;
status_t status = server.Read(category, cddbID, "", readResponse, verbose);
if (status != B_OK) {
fprintf(stderr, "Could not read detailed CD entry from server: %s\n",
strerror(status));
return status;
}
_Dump(readResponse);
return B_OK;
}
Header::Header(uint64 lastBlock, uint32 blockSize)
:
fBlockSize(blockSize),
fStatus(B_NO_INIT),
fEntries(NULL)
{
TRACE(("EFI::Header: Initialize GPT, block size %" B_PRIu32 "\n",
blockSize));
// Initialize to an empty header
memcpy(fHeader.header, EFI_PARTITION_HEADER, sizeof(fHeader.header));
fHeader.SetRevision(EFI_TABLE_REVISION);
fHeader.SetHeaderSize(sizeof(fHeader));
fHeader.SetHeaderCRC(0);
fHeader.SetAbsoluteBlock(EFI_HEADER_LOCATION);
fHeader.SetAlternateBlock(lastBlock);
uuid_t uuid;
uuid_generate_random(uuid);
memcpy((uint8*)&fHeader.disk_guid, uuid, sizeof(guid_t));
fHeader.SetEntriesBlock(EFI_PARTITION_ENTRIES_BLOCK);
fHeader.SetEntryCount(EFI_PARTITION_ENTRY_COUNT);
fHeader.SetEntrySize(EFI_PARTITION_ENTRY_SIZE);
fHeader.SetEntriesCRC(0);
size_t arraySize = _EntryArraySize();
fEntries = new (std::nothrow) uint8[arraySize];
if (fEntries == NULL) {
fStatus = B_NO_MEMORY;
return;
}
memset(fEntries, 0, arraySize);
// TODO: initialize the entry guids
uint32 entryBlocks = (arraySize + fBlockSize - 1) / fBlockSize;
fHeader.SetFirstUsableBlock(EFI_PARTITION_ENTRIES_BLOCK + entryBlocks);
fHeader.SetLastUsableBlock(lastBlock - 1 - entryBlocks);
_SetBackupHeaderFromPrimary(lastBlock);
#ifdef TRACE_EFI_GPT
_Dump(fHeader);
_DumpPartitions();
#endif
fStatus = B_OK;
}
static void callBackEnd( // CALL-BACK: end of condition block
void* data ) // - COND_STK entry
{
COND_STK* cond = data; // - COND_STK entry
SE* posn; // - current position
_Dump( cond, "CallBack(END)" );
posn = FstabCurrPosn();
#if 0
if( posn == cond->posn_true
&& posn == cond->posn_false ) {
cond->mask_set = 0;
cond->mask_clr = NOT_BITARR_MASK( 0 );
BlkPosnTempBegSet( posn );
} else {
#else
{
#endif
SE* test = FstabTestFlag( cond->offset
, cond->posn_last
, posn );
FstabAdd( test );
BlkPosnTempBegSet( test );
}
callBackFini( cond );
}
static void callBackNewCtorBeg( // CALL-BACK: start of new ctor
void* data ) // - COND_STK entry
{
COND_STK* cond = data; // - COND_STK entry
SE* posn; // - current position
SE* se; // - new test_flag entry
posn = callBackCurrent( cond );
DbgVerify( NULL != posn, "callBackNewCtorBeg -- no delete SE" );
se = FstabTestFlag( cond->offset, posn, FstabPrevious( posn ) );
cond->posn_true = se;
FstabAdd( se );
BlkPosnTempBegSet( se );
}
Header::Header(int fd, uint64 lastBlock, uint32 blockSize)
:
fBlockSize(blockSize),
fStatus(B_NO_INIT),
fEntries(NULL)
{
// TODO: check the correctness of the protective MBR and warn if invalid
// Read and check the partition table header
fStatus = _Read(fd, (uint64)EFI_HEADER_LOCATION * blockSize,
&fHeader, sizeof(efi_table_header));
if (fStatus == B_OK) {
if (!_IsHeaderValid(fHeader, EFI_HEADER_LOCATION))
fStatus = B_BAD_DATA;
}
if (fStatus == B_OK && lastBlock != fHeader.AlternateBlock()) {
dprintf("gpt: alternate header not in last block (%" B_PRIu64 " vs. %"
B_PRIu64 ")\n", fHeader.AlternateBlock(), lastBlock);
lastBlock = fHeader.AlternateBlock();
}
// Read backup header, too
status_t status = _Read(fd, lastBlock * blockSize, &fBackupHeader,
sizeof(efi_table_header));
if (status == B_OK) {
if (!_IsHeaderValid(fBackupHeader, lastBlock))
status = B_BAD_DATA;
}
// If both headers are invalid, bail out -- this is probably not a GPT disk
if (status != B_OK && fStatus != B_OK)
return;
if (fStatus != B_OK) {
// Recreate primary header from the backup
fHeader = fBackupHeader;
fHeader.SetAbsoluteBlock(EFI_HEADER_LOCATION);
fHeader.SetEntriesBlock(EFI_PARTITION_ENTRIES_BLOCK);
fHeader.SetAlternateBlock(lastBlock);
} else if (status != B_OK) {
// Recreate backup header from primary
_SetBackupHeaderFromPrimary(lastBlock);
}
// allocate, read, and check partition entry array
fEntries = new (std::nothrow) uint8[_EntryArraySize()];
if (fEntries == NULL) {
// TODO: if there cannot be allocated enough (ie. the boot loader's
// heap is limited), try a smaller size before failing
fStatus = B_NO_MEMORY;
return;
}
fStatus = _Read(fd, fHeader.EntriesBlock() * blockSize,
fEntries, _EntryArraySize());
if (fStatus != B_OK || !_ValidateEntriesCRC()) {
// Read backup entries instead
fStatus = _Read(fd, fBackupHeader.EntriesBlock() * blockSize,
fEntries, _EntryArraySize());
if (fStatus != B_OK)
return;
if (!_ValidateEntriesCRC()) {
fStatus = B_BAD_DATA;
return;
}
}
// TODO: check overlapping or out of range partitions
#ifdef TRACE_EFI_GPT
_Dump(fHeader);
_Dump(fBackupHeader);
_DumpPartitions();
#endif
fStatus = B_OK;
}
