void SpTraceVcd::open (const char* filename) {
if (isOpen()) return;
// SPDIFF_OFF
// Assertions, as we cast enum to uint32_t pointers in AutoTrace.pm
enum SpTraceVcd_enumtest { FOO = 1 };
if (sizeof(SpTraceVcd_enumtest) != sizeof(uint32_t)) {
SP_ABORT("%Error: SpTraceVcd::open cast assumption violated\n");
}
// SPDIFF_ON
// Set member variables
m_filename = filename;
s_vcdVecp.push_back(this);
openNext (m_rolloverMB!=0);
if (!isOpen()) return;
dumpHeader();
// Allocate space now we know the number of codes
if (!m_sigs_oldvalp) {
m_sigs_oldvalp = new uint32_t [m_nextCode+10];
}
if (m_rolloverMB) {
openNext(true);
if (!isOpen()) return;
}
}
void HttpReply::finishedSlot()
{
QString status(headerValue("Qchemserv-Status"));
qDebug() << "HttpReply finishedSlot called with header";
qDebug() << "-------------------------------------------------------------";
dumpHeader();
qDebug() << "HttpReply finishedSlot called with message";
qDebug() << m_message;
qDebug() << "HttpReply finishedSlot called with status";
qDebug() << status;
qDebug() << "-------------------------------------------------------------";
if (status.contains("OK")) {
if (m_status != Error) m_status = m_interrupt ? Interrupted : Finished;
if (m_message.isEmpty()) {
QLOG_TRACE() << "HttpReply message empty, returning header";
m_message = headerAsString();
}
}else if (status.contains("ERROR")) {
m_status = Error;
m_message = headerValue("Qchemserv-Error");
}else {
m_status = Error;
m_message = "QChem server temporarily unavailable";
}
finished();
}
void BasicBlock::deepDump(PrintStream& out) const
{
dumpHeader(out);
for (const Inst& inst : *this)
out.print(" ", inst, "\n");
dumpFooter(out);
}
static void outputIMASK_H( char **argv )
{
NAME **h;
NAME *m;
NAME *n;
// output name cannot match icmask.* because makefile execs del icmask.*
out_h = fopen( "ic_mask.gh", "w" );
if( out_h == NULL ) fail( "cannot open 'icmask.gh' for output\n" );
dumpHeader( argv );
for( h = &icMaskTable; h <= &icMaskTable[IC_END]; ++h ) {
if( *h != NULL ) {
for( m = *h; m != NULL; m = n ) {
n = m->next;
if( n != NULL ) {
fprintf( out_h, "ICOPM_%s|", m->name );
} else {
fprintf( out_h, "ICOPM_%s, /* %s */\n", m->name, ic_names[ h - icMaskTable ] );
}
}
} else {
fprintf( out_h, "0, /* %s */\n", ic_names[ h - icMaskTable ] );
}
if( icPreProcTable[ h - icMaskTable ] != NULL ) {
fprintf( out_h, "%s\n", icPreProcTable[ h - icMaskTable ]->name );
}
}
fclose( out_h );
}
void VerilatedVcd::open (const char* filename) {
if (isOpen()) return;
// Set member variables
m_filename = filename;
s_vcdVecp.push_back(this);
// SPDIFF_OFF
// Set callback so an early exit will flush us
Verilated::flushCb(&flush_all);
// SPDIFF_ON
openNext (m_rolloverMB!=0);
if (!isOpen()) return;
dumpHeader();
// Allocate space now we know the number of codes
if (!m_sigs_oldvalp) {
m_sigs_oldvalp = new vluint32_t [m_nextCode+10];
}
if (m_rolloverMB) {
openNext(true);
if (!isOpen()) return;
}
}
void JITDisassembler::dump(PrintStream& out, LinkBuffer& linkBuffer)
{
dumpHeader(out, linkBuffer);
dumpDisassembly(out, linkBuffer, m_startOfCode, m_labelForBytecodeIndexInMainPath[0]);
dumpForInstructions(out, linkBuffer, " ", m_labelForBytecodeIndexInMainPath, firstSlowLabel());
out.print(" (End Of Main Path)\n");
dumpForInstructions(out, linkBuffer, " (S) ", m_labelForBytecodeIndexInSlowPath, m_endOfSlowPath);
out.print(" (End Of Slow Path)\n");
dumpDisassembly(out, linkBuffer, m_endOfSlowPath, m_endOfCode);
}
bool AndroidFormat::loadHeader(const unsigned char *data, std::size_t size,
const std::size_t headerIndex)
{
// Make sure the file is large enough to contain the header
if (size < headerIndex + sizeof(BootImageHeader)) {
LOGE("Boot image header exceeds size by %" PRIzu " bytes",
headerIndex + sizeof(BootImageHeader) - size);
return false;
}
// Read the Android boot image header
auto hdr = reinterpret_cast<const BootImageHeader *>(&data[headerIndex]);
// Read the page size
switch (hdr->page_size) {
case 2048:
case 4096:
case 8192:
case 16384:
case 32768:
case 65536:
case 131072:
break;
default:
LOGE("Invalid page size: %u", hdr->page_size);
return false;
}
dumpHeader(hdr);
// Save header fields
mI10e->kernelAddr = hdr->kernel_addr;
mI10e->ramdiskAddr = hdr->ramdisk_addr;
mI10e->secondAddr = hdr->second_addr;
mI10e->tagsAddr = hdr->tags_addr;
mI10e->pageSize = hdr->page_size;
mI10e->boardName = StringUtils::toMaxString(
reinterpret_cast<const char *>(hdr->name), BOOT_NAME_SIZE);
mI10e->cmdline = StringUtils::toMaxString(
reinterpret_cast<const char *>(hdr->cmdline), BOOT_ARGS_SIZE);
// Raw header fields
mI10e->hdrKernelSize = hdr->kernel_size;
mI10e->hdrRamdiskSize = hdr->ramdisk_size;
mI10e->hdrSecondSize = hdr->second_size;
mI10e->hdrDtSize = hdr->dt_size;
mI10e->hdrUnused = hdr->unused;
for (std::size_t i = 0; i < sizeof(hdr->id) / sizeof(hdr->id[0]); ++i) {
mI10e->hdrId[i] = hdr->id[i];
}
return true;
}
bool SimpleTableDump::dump(std::string name, std::shared_ptr<AbstractTable> table) {
verify(table);
auto mainTable = std::dynamic_pointer_cast<Store>(table)->getMainTables()[0];
prepare(name);
for(size_t i=0; i < mainTable->columnCount(); ++i) {
// For each attribute dump dictionary and values
dumpDictionary(name, mainTable, i);
dumpAttribute(name, mainTable, i);
}
dumpHeader(name, mainTable);
dumpMetaData(name, mainTable);
return true;
}
bool SimpleTableDump::dumpDelta(std::string name, atable_ptr_t table) {
verify(table);
auto deltaTable = std::dynamic_pointer_cast<Store>(table)->getDeltaTable();
prepare(name);
for (size_t i = 0; i < deltaTable->columnCount(); ++i) {
// For each attribute dump dictionary and values
dumpDictionary(name, deltaTable, i, true);
dumpAttribute(name, deltaTable, i);
}
dumpHeader(name, deltaTable);
dumpMetaData(name, deltaTable);
return true;
}
void JITDisassembler::reportToProfiler(Profiler::Compilation* compilation, LinkBuffer& linkBuffer)
{
StringPrintStream out;
dumpHeader(out, linkBuffer);
compilation->addDescription(Profiler::CompiledBytecode(Profiler::OriginStack(), out.toCString()));
out.reset();
dumpDisassembly(out, linkBuffer, m_startOfCode, m_labelForBytecodeIndexInMainPath[0]);
compilation->addDescription(Profiler::CompiledBytecode(Profiler::OriginStack(), out.toCString()));
reportInstructions(compilation, linkBuffer, " ", m_labelForBytecodeIndexInMainPath, firstSlowLabel());
compilation->addDescription(Profiler::CompiledBytecode(Profiler::OriginStack(), " (End Of Main Path)\n"));
reportInstructions(compilation, linkBuffer, " (S) ", m_labelForBytecodeIndexInSlowPath, m_endOfSlowPath);
compilation->addDescription(Profiler::CompiledBytecode(Profiler::OriginStack(), " (End Of Slow Path)\n"));
out.reset();
dumpDisassembly(out, linkBuffer, m_endOfSlowPath, m_endOfCode);
compilation->addDescription(Profiler::CompiledBytecode(Profiler::OriginStack(), out.toCString()));
}
static void
doOneImage(const char * const name,
unsigned int const imageDoneCount,
FILE * const fileP,
bool const allimages,
bool const justCount,
bool const wantComments,
bool * const eofP) {
struct pam pam;
const char * comments;
enum pm_check_code checkRetval;
pam.comment_p = &comments;
pnm_readpaminit(fileP, &pam, PAM_STRUCT_SIZE(comment_p));
if (!justCount) {
if (allimages)
printf("%s:\tImage %d:\t", name, imageDoneCount);
else
printf("%s:\t", name);
dumpHeader(pam);
if (wantComments)
dumpComments(comments);
}
strfree(comments);
pnm_checkpam(&pam, PM_CHECK_BASIC, &checkRetval);
if (allimages) {
tuple * tuplerow;
unsigned int row;
tuplerow = pnm_allocpamrow(&pam);
for (row = 0; row < pam.height; ++row)
pnm_readpamrow(&pam, tuplerow);
pnm_freepamrow(tuplerow);
pnm_nextimage(fileP, eofP);
}
}
int dumpAll(struct file *f, struct task_struct *tsk)
{
mm_segment_t fs;
int vmareas, openfiles, pagessofar;
struct pt_regs prset;
printk(KERN_INFO "\nDumpStructure():Dumping structure....................\n");
prset=GetRegisters(tsk);
fs=get_fs();
dumpHeader(f,tsk,&vmareas,&openfiles,&pagessofar);
dumpTaskStructure(f,tsk);
dumpMMStructure(f,tsk);
DumpVMAreas(f,tsk,fs);
DumpRegisters(f,prset);
kwrite(f,NULL,0);
set_fs(fs);
return 1;
}
static void outputIMASK_H( char **argv )
{
NAME *m;
NAME *n;
int i;
// output name cannot match icmask.* because makefile execs del icmask.*
out_h = fopen( "ic_mask.gh", "w" );
if( out_h == NULL ) fail( "cannot open 'icmask.gh' for output\n" );
dumpHeader( argv );
for( i = 0; i <= IC_END; ++i ) {
m = icMaskTable[i];
if( m == NULL ) {
if( ic_masks[i] == NULL ) {
fprintf( out_h, "0, /* %s */\n", ic_names[i] );
} else {
fprintf( out_h, "0|%s, /* %s */\n", ic_masks[i], ic_names[i] );
}
} else {
for( ; m != NULL; m = n ) {
n = m->next;
if( n == NULL ) {
break;
}
fprintf( out_h, "ICOPM_%s|", m->name );
}
if( ic_masks[i] == NULL ) {
fprintf( out_h, "ICOPM_%s, /* %s */\n", m->name, ic_names[i] );
} else {
fprintf( out_h, "ICOPM_%s|%s, /* %s */\n", m->name, ic_masks[i], ic_names[i] );
}
}
for( m = icPreProcTable[i]; m != NULL; m = m->next ) {
fprintf( out_h, "%s", m->name );
}
}
fclose( out_h );
}
static void dumpNetSnmp(int modc, SmiModule **modv, int flags, char *output)
{
char *baseName;
int i;
if (flags & SMIDUMP_FLAG_UNITE) {
/* not implemented yet */
} else {
for (i = 0; i < modc; i++) {
baseName = output ? output : translateFileName(modv[i]->name);
dumpHeader(modv[i], baseName);
if (! noAgtStubs) {
dumpAgtStub(modv[i], baseName);
dumpAgtImpl(modv[i], baseName);
}
if (! noMgrStubs) {
dumpMgrStub(modv[i], baseName);
}
if (! output) xfree(baseName);
}
}
}
Vector<Disassembler::DumpedOp> Disassembler::createDumpList(LinkBuffer& linkBuffer)
{
StringPrintStream out;
Vector<DumpedOp> result;
CodeOrigin previousOrigin = CodeOrigin();
dumpHeader(out, linkBuffer);
append(result, out, previousOrigin);
m_graph.m_dominators.computeIfNecessary(m_graph);
m_graph.m_naturalLoops.computeIfNecessary(m_graph);
const char* prefix = " ";
const char* disassemblyPrefix = " ";
Node* lastNode = 0;
MacroAssembler::Label previousLabel = m_startOfCode;
for (size_t blockIndex = 0; blockIndex < m_graph.numBlocks(); ++blockIndex) {
BasicBlock* block = m_graph.block(blockIndex);
if (!block)
continue;
dumpDisassembly(out, disassemblyPrefix, linkBuffer, previousLabel, m_labelForBlockIndex[blockIndex], lastNode);
append(result, out, previousOrigin);
m_graph.dumpBlockHeader(out, prefix, block, Graph::DumpLivePhisOnly, &m_dumpContext);
append(result, out, previousOrigin);
Node* lastNodeForDisassembly = block->at(0);
for (size_t i = 0; i < block->size(); ++i) {
MacroAssembler::Label currentLabel;
HashMap<Node*, MacroAssembler::Label>::iterator iter = m_labelForNode.find(block->at(i));
if (iter != m_labelForNode.end())
currentLabel = iter->value;
else {
// Dump the last instruction by using the first label of the next block
// as the end point. This case is hit either during peephole compare
// optimizations (the Branch won't have its own label) or if we have a
// forced OSR exit.
if (blockIndex + 1 < m_graph.numBlocks())
currentLabel = m_labelForBlockIndex[blockIndex + 1];
else
currentLabel = m_endOfMainPath;
}
dumpDisassembly(out, disassemblyPrefix, linkBuffer, previousLabel, currentLabel, lastNodeForDisassembly);
append(result, out, previousOrigin);
previousOrigin = block->at(i)->origin.semantic;
if (m_graph.dumpCodeOrigin(out, prefix, lastNode, block->at(i), &m_dumpContext)) {
append(result, out, previousOrigin);
previousOrigin = block->at(i)->origin.semantic;
}
m_graph.dump(out, prefix, block->at(i), &m_dumpContext);
lastNode = block->at(i);
lastNodeForDisassembly = block->at(i);
}
}
dumpDisassembly(out, disassemblyPrefix, linkBuffer, previousLabel, m_endOfMainPath, lastNode);
append(result, out, previousOrigin);
out.print(prefix, "(End Of Main Path)\n");
append(result, out, previousOrigin);
dumpDisassembly(out, disassemblyPrefix, linkBuffer, previousLabel, m_endOfCode, 0);
append(result, out, previousOrigin);
m_dumpContext.dump(out, prefix);
append(result, out, previousOrigin);
return result;
}
//**********************************************
uint8_t ADM_vob2vobsub(char *nameVob, char *nameVobSub, char *nameIfo)
{
dmx_demuxerPS *demuxer=NULL;
DIA_working *working=NULL;
MPEG_TRACK track;
FILE *indexFile=NULL;
FILE *indexSub=NULL;
uint32_t palette[16],width,height;
uint64_t abs,rel,size,pts;
int blockSize;
uint8_t *data,stream;
char *subname;
double percent;
uint32_t packetLen,usedLen,read;
OneTrack allIndex[MAX_LANGUAGE];
char language[MAX_LANGUAGE*4];
#ifdef TEST_V2V
nameIfo="d:/Crime/VTS_01_0.IFO";
nameVobSub="toto.idx";
#endif
printf("v2v: Ifo:%s Vob:%s Vsub:%s\n",nameIfo,nameVob,nameVobSub);
memset(language,0,sizeof(language));
memset(palette,0,sizeof(uint32_t)*16);
if(!vobsub_parse_ifo(nameIfo,palette,&width,&height,language))
{
GUI_Error_HIG(QT_TR_NOOP("Ifo error"),QT_TR_NOOP("Error reading ifo file, aborting."));
return 0;
}
printf("Ifo: %d x %d\n",width,height);
indexFile=fopen(nameVobSub,"wt");
if(!indexFile)
{
GUI_Error_HIG(QT_TR_NOOP("Cannot write .idx"),NULL);
return 0;
}
subname=ADM_strdup(nameVobSub);
size=strlen(subname);
subname[size-3]='s';
subname[size-2]='u';
subname[size-1]='b';
indexSub=fopen(subname,"wb");
ADM_dealloc(subname);
if(!indexSub)
{
fclose(indexFile);
GUI_Error_HIG(QT_TR_NOOP("Cannot write .sub"),NULL);
return 0;
}
for(int i=0;i<MAX_LANGUAGE;i++)
{
allIndex[i].setLang(language+i*3);
}
track.pes=0x20;
track.pid=track.pes;
demuxer=new dmx_demuxerPS(1,&track,1);
if(!demuxer->open(nameVob))
{
GUI_Error_HIG(QT_TR_NOOP("Problem opening the mpeg files"),NULL);
delete demuxer;
fclose(indexFile);
fclose(indexSub);
return 0;
}
size=demuxer->getSize();
int display=0;
dumpHeader(indexFile,0,width,height,palette);
working=new DIA_working(QT_TR_NOOP("Generating VobSub file"));
//*** Main Loop ***
uint32_t startPts=0,lastPts=0;
uint16_t hh,mm,ss,ms;
uint32_t timestamp;
while(1)
{
if(!demuxer->forceRefill(&stream)) goto _abt;
demuxer->getPos(&abs,&rel);
display++;
if(display>20)
{
working->update(abs>>10,size>>10);
display=0;
}
#ifdef TEST_V2V
//if(abs>200*1024*1024) break;
#endif
if(stream>=0x20 && stream<0x20+MAX_LANGUAGE)
{
demuxer->getPacketInfo(&data,&packetLen,&usedLen,&pts);
if(pts!=ADM_NO_PTS)
{
// Wrap around ?
if(lastPts)
{
if(pts<lastPts)
{
if(lastPts-pts>MIN_WRAP_VALUE)
{
printf("Wrapping at %u ",lastPts);
startPts+=lastPts;
timestamp=startPts/90;
ms2time(timestamp,&hh,&mm,&ss,&ms);
printf("%02d:%02d:%02d \n",hh,mm,ss);
}
}
}
lastPts=pts;
pts+=startPts;
}
#if 0
if(pts!=ADM_NO_PTS)
{
timestamp=pts/90;
ms2time(timestamp,&hh,&mm,&ss,&ms);
printf("%02d:%02d:%02d \n",hh,mm,ss);
}
#endif
blockSize=demuxer->read16i();
allIndex[stream-0x20].run(blockSize,data,packetLen,usedLen, pts) ;
}
}
/// Dump the object to the given output stream.
/// @throw Invalid Request if the required data has not been stored.
virtual void dump(std::ostream& os = std::cout) const
{
dumpHeader(os);
dumpBody(os);
}
int
main(int argc, char* argv[])
{
bool add = false, create = false, destroy = false, erase = false, header = false;
bool list = false, lvcreate = false, lvdestroy = false, lvlist = false, lvmodify = false, lvresize = false, lvsnap = false;
bool modify = false, remove = false, spare = false, watch = false;
char * setLevel = 0, * setName = 0;
/* options descriptor */
static struct option longopts[] = {
{ "add", required_argument, 0, 'a' },
{ "create", no_argument, 0, 'c' },
{ "destroy", required_argument, 0, 'd' },
{ "erase", no_argument, 0, 'e' },
{ "header", no_argument, 0, 'h' },
{ "list", no_argument, 0, 'l' },
{ "modify", required_argument, 0, 'm' },
{ "remove", required_argument, 0, 'r' },
{ "spare", required_argument, 0, 's' },
{ "watch", no_argument, 0, 'w' },
{ "lvcreate", required_argument, 0, 'C' },
{ "lvdestroy", required_argument, 0, 'D' },
{ "lvlist", no_argument, 0, 'L' },
{ "lvmodify", required_argument, 0, 'M' },
{ "lvresize", required_argument, 0, 'R' },
{ "lvsnap", required_argument, 0, 'S' },
{ "auto-rebuild",required_argument, 0, 'A' },
{ "block-size", required_argument, 0, 'B' },
{ "extents", no_argument, 0, 'E' },
{ "hint", required_argument, 0, 'H' },
{ "level", required_argument, 0, 'V' },
{ "name", required_argument, 0, 'N' },
{ "quick-rebuild",required_argument, 0, 'Q' },
{ "size", required_argument, 0, 'Z' },
{ "timeout", required_argument, 0, 'T' },
{ "verbose", no_argument, 0, 'v' },
{ "help", no_argument, 0, '?' },
{ 0, 0, 0, 0 }
};
int ch;
while ((ch = getopt_long(argc, argv, "a:cd:ehlm:r:s:wC:D:LM:R:S:A:B:EH:V:N:Q:Z:T:v?", longopts, NULL)) != -1) {
switch(ch) {
case 'a':
add = true;
setName = strdup(optarg);
break;
case 'c':
create = true;
break;
case 'd':
destroy = true;
setName = strdup(optarg);
break;
case 'e':
erase = true;
break;
case 'h':
header = true;
break;
case 'l':
list = true;
break;
case 'm':
modify = true;
setName = strdup(optarg);
break;
case 'r':
remove = true;
setName = strdup(optarg);
break;
case 's':
spare = true;
setName = strdup(optarg);
break;
case 'w':
watch = true;
break;
case 'C':
lvcreate = true;
setName = strdup(optarg);
break;
case 'D':
lvdestroy = true;
setName = strdup(optarg);
break;
case 'L':
lvlist = true;
break;
case 'M':
lvmodify = true;
setName = strdup(optarg);
break;
case 'R':
lvresize = true;
setName = strdup(optarg);
break;
case 'S':
lvsnap = true;
setName = strdup(optarg);
break;
case 'A':
autoRebuild = ((optarg[0] == 'Y') || (optarg[0] == 'y')) ? AUTO_YES : AUTO_NO;
break;
case 'B':
sscanf(optarg, "%lli", &blockSize);
break;
case 'E':
extents = true;
break;
case 'H':
hint = strdup(optarg);
break;
case 'V':
setLevel = strdup(optarg);
break;
case 'N':
nickname = strdup(optarg);
break;
case 'Q':
quickRebuild = ((optarg[0] == 'Y') || (optarg[0] == 'y')) ? AUTO_YES : AUTO_NO;
break;
case 'Z':
sscanf(optarg, "%lli", &volSize);
break;
case 'T':
sscanf(optarg, "%lli", &timeout);
break;
case 'v':
verbose = true;
break;
case 0:
case '?':
default:
usage();
exit(0);
}
}
argc -= optind;
argv += optind;
if (!add && !create && !destroy && !erase && !header && !list && !modify && !remove && !spare && !watch &&
!lvcreate && !lvdestroy && !lvlist && !lvmodify && !lvresize && !lvsnap) {
usage();
exit(0);
}
if (list) {
listRAIDSets();
exit(0);
}
if (lvlist) {
listLogicalVolumes(NULL, argc, argv);
exit(0);
}
if (geteuid()) {
printf("ERROR: you must be super user for this operation.\n");
exit(1);
}
if (erase) {
erasePartition(argc, argv);
exit(0);
};
if (header) {
dumpHeader(argc, argv);
exit(0);
};
if (watch) {
CFNotificationCenterAddObserver(CFNotificationCenterGetLocalCenter(),
NULL, // const void *observer
callBack,
CFSTR(kAppleRAIDNotificationSetDiscovered),
NULL, // const void *object
CFNotificationSuspensionBehaviorHold);
CFNotificationCenterAddObserver(CFNotificationCenterGetLocalCenter(),
NULL, // const void *observer
callBack,
CFSTR(kAppleRAIDNotificationSetTerminated),
NULL, // const void *object
CFNotificationSuspensionBehaviorHold);
CFNotificationCenterAddObserver(CFNotificationCenterGetLocalCenter(),
NULL, // const void *observer
callBack,
CFSTR(kAppleRAIDNotificationSetChanged),
NULL, // const void *object
CFNotificationSuspensionBehaviorHold);
CFNotificationCenterAddObserver(CFNotificationCenterGetLocalCenter(),
NULL, // const void *observer
callBack,
CFSTR(kAppleLVMNotificationVolumeDiscovered),
NULL, // const void *object
CFNotificationSuspensionBehaviorHold);
CFNotificationCenterAddObserver(CFNotificationCenterGetLocalCenter(),
NULL, // const void *observer
callBack,
CFSTR(kAppleLVMNotificationVolumeTerminated),
NULL, // const void *object
CFNotificationSuspensionBehaviorHold);
CFNotificationCenterAddObserver(CFNotificationCenterGetLocalCenter(),
NULL, // const void *observer
callBack,
CFSTR(kAppleLVMNotificationVolumeChanged),
NULL, // const void *object
CFNotificationSuspensionBehaviorHold);
// this will not fail if there is no raid controller, ie, if AppleRAID class is not instantiated in the kernel
AppleRAIDEnableNotifications();
}
if (add) addMember(setName, CFSTR(kAppleRAIDMembersKey), argc, argv);
if (create) createSet(setLevel, nickname, argc, argv);
if (destroy) destroySet(setName, argc, argv);
if (modify) modifySet(setName, argc, argv);
if (remove) removeMember(setName, argc, argv);
if (spare) addMember(setName, CFSTR(kAppleRAIDSparesKey), argc, argv);
if (lvcreate) createLogicalVolume(setName, setLevel, argc, argv);
if (lvdestroy) destroyLogicalVolume(setName, argc, argv);
if (lvmodify) modifyLogicalVolume(setName, argc, argv);
if (lvresize) resizeLogicalVolume(setName, argc, argv);
if (lvsnap) snapshotLogicalVolume(setName, setLevel, argc, argv);
if (watch) {
printf("watching...\n");
// Set up a signal handler so we can clean up when we're interrupted from the command line
// Otherwise we stay in our run loop forever.
sig_t oldHandler = signal(SIGINT, signalHandler);
if (oldHandler == SIG_ERR) {
printf("Could not establish new signal handler");
exit(1);
}
// Start the run loop. Now we'll receive notifications.
//
printf("Starting run loop.\n");
CFRunLoopRun();
printf("Unexpectedly back from CFRunLoopRun()!\n");
}
return 0;
}
/*********************************************************************
功能：虚函数：打印整个文件内容
参数：无
返回：无
作者：刘远安 2013-08-23
*********************************************************************/
void CFixedLenRecordFile::dump()
{
dumpHeader();
//打印文件体，在子类实现
}
void PCHeaderCreate( char *include_file )
/***************************************/
{
char * volatile pch_fname; // must be preserved by setjmp()
int status;
auto jmp_buf restore_state;
#ifndef NDEBUG
clock_t start;
clock_t stop;
start = clock();
#endif
if( ErrCount != 0 ) {
return;
}
if( CompFlags.fhr_switch_used ) {
// treat any .PCH as read-only (do not create one)
return;
}
pch_fname = PCHFileName();
pchFile = sopen4( pch_fname, O_RDWR | O_BINARY | O_CREAT | O_TRUNC, SH_DENYRW, PMODE_RW );
if( pchFile == -1 ) {
CErr2p( ERR_PCH_CREATE_ERROR, pch_fname );
return;
}
bufferPosition = 0;
ioBuffer = CMemAlloc( IO_BUFFER_SIZE );
bufferCursor = ioBuffer;
amountLeft = IO_BUFFER_SIZE;
abortData = &restore_state;
status = setjmp( restore_state );
if( status == 0 ) {
unsigned long brinf_posn;
if( CompFlags.pch_debug_info_opt ) {
pchDebugInfoName = CppPCHDebugInfoName( include_file );
}
dumpHeader();
dumpCheckData( include_file );
execInitFunctions( true );
execControlFunctions( true, writeFunctions );
execFiniFunctions( true );
brinf_posn = BrinfPch( pchFile );
PCHFlushBuffer();
// keep this PCH file
pch_fname = NULL;
setOKHeader( brinf_posn );
} else {
CErr1( ERR_PCH_WRITE_ERROR );
}
abortData = NULL;
CMemFreePtr( &ioBuffer );
close( pchFile );
if( pch_fname != NULL ) {
// write error occurred; delete PCH file
remove( pch_fname );
} else {
if( CompFlags.pch_debug_info_opt ) {
CompFlags.pch_debug_info_write = true;
CompFlags.all_debug_type_names = true;
}
}
#ifndef NDEBUG
stop = clock();
printf( "%u ticks to parse header\n", (unsigned)( start - start_parse ) );
printf( "%u ticks to save pre-compiled header\n", (unsigned)( stop - start ) );
#endif
}