bool Start()
{
stopTrace(); // stop old
startTrace();
if (!m_kernelSession.Init(true, KERNEL_LOGGER_NAMEW) ||
!m_heapSession.Init(true, HEAP_LOGGER_NAMEW))
{
stopTrace();
return false;
}
m_kernelSession.Start();
m_heapSession.Start();
m_flusher.Start();
_ThreadBase::Start();
return true;
}
int main(int argc, char **argv)
{
bool isRoot = (getuid() == 0);
if (argc == 2 && 0 == strcmp(argv[1], "--help")) {
showHelp(argv[0]);
exit(0);
}
for (;;) {
int ret;
ret = getopt(argc, argv, "b:gcidflst:wz");
if (ret < 0) {
break;
}
switch(ret) {
case 'g':
if (!isRoot) {
fprintf(stderr, "error: tracing GPU power state requires root privileges\n");
exit(1);
}
g_traceGpuPower = true;
break;
case 'b':
g_traceBufferSizeKB = atoi(optarg);
break;
case 'c':
g_traceOverwrite = true;
break;
case 'i':
g_traceCpuIdle = true;
break;
case 'l':
g_traceGovernorLoad = true;
break;
case 'd':
if (!isRoot) {
fprintf(stderr, "error: tracing disk activity requires root privileges\n");
exit(1);
}
g_traceDisk = true;
break;
case 'f':
g_traceCpuFrequency = true;
break;
case 's':
g_traceSchedSwitch = true;
break;
case 't':
g_traceDurationSeconds = atoi(optarg);
break;
case 'w':
if (!isRoot) {
fprintf(stderr, "error: tracing kernel work queues requires root privileges\n");
exit(1);
}
g_traceWorkqueue = true;
break;
case 'z':
g_compress = true;
break;
default:
fprintf(stderr, "\n");
showHelp(argv[0]);
exit(-1);
break;
}
}
registerSigHandler();
bool ok = startTrace(isRoot);
if (ok) {
printf("capturing trace...");
fflush(stdout);
// We clear the trace after starting it because tracing gets enabled for
// each CPU individually in the kernel. Having the beginning of the trace
// contain entries from only one CPU can cause "begin" entries without a
// matching "end" entry to show up if a task gets migrated from one CPU to
// another.
ok = clearTrace();
if (ok) {
// Sleep to allow the trace to be captured.
struct timespec timeLeft;
timeLeft.tv_sec = g_traceDurationSeconds;
timeLeft.tv_nsec = 0;
do {
if (g_traceAborted) {
break;
}
} while (nanosleep(&timeLeft, &timeLeft) == -1 && errno == EINTR);
}
}
// Stop the trace and restore the default settings.
stopTrace(isRoot);
if (ok) {
if (!g_traceAborted) {
printf(" done\nTRACE:\n");
fflush(stdout);
dumpTrace();
} else {
printf("\ntrace aborted.\n");
fflush(stdout);
}
clearTrace();
} else {
fprintf(stderr, "unable to start tracing\n");
}
// Reset the trace buffer size to 1.
setTraceBufferSizeKB(1);
return g_traceAborted ? 1 : 0;
}
// if you haven't started the stethoscope
// then the output is saved in a file
str
CMDstartTracePath(void *res, str *path)
{
(void) res;
return startTrace(*path);
}
// called by the SQL front end.
str
CMDstartTrace(void *res)
{
(void) res;
return startTrace(0);
}
bool start_ndfsm(int argc, char** argv, ndfsm* test)
{
NDFSM_TestEngineData ndfsm_state;
bool tracing_was_started_here = false;
bool was_accidental_transition_traced;
AssertionExit prev_assert = NULL;
TestSystemParameters* pars;
bool verdict;
bool verdict_init;
// Initialize test engine data
init_NDFSM_TestEngineData( &ndfsm_state, test );
// Process standard parameters
pars = processStandardParameters(test->name,test->actions,argc,argv);
assertion( pars != NULL, "start_ndfsm: standard parameters processing fails");
// Start tracing if it has not been started yet
if (!isInTrace())
{
tracing_was_started_here = true;
prev_assert = ts_setup_assert_function();
startTrace();
}
START_EXCEPTION_PROTECTED_SECTION(ts_default_exception_handler);
setCurrentTestScenarioName(test->name);
traceScenarioStart(test->name);
traceScenarioParameters(pars->argc,pars->argv);
// Scenario initialization
verdict = true;
if (test->init != NULL)
{
// Trace pseudo transition start
was_accidental_transition_traced = setTraceAccidental(true);
traceState("start");
traceScenarioValue ("state", "", "", "start");
traceTransitionStart("initialize");
traceScenarioValue ("scenario method", "", "", "initialize");
// Call 'init' function
clearOracleVerdict();
verdict_init = test->init(pars->argc, pars->argv);
verdict = verdict_init && getOracleVerdict();
// Frame end
verdict = onFrameEnd( &ndfsm_state.executor.model_state, verdict );
// Trace initialization failed message
if (!verdict_init)
{
traceException(SCENARIO_INITIALIZATION_FAILED_MESSAGE);
testVerdict = TD_faulted;
}
// Trace pseudo transition end
traceTransitionEnd();
setTraceAccidental(was_accidental_transition_traced);
}
// FSM traversing
if (verdict)
{if (check_consistency_NDFSM(test))
{
traceProperties_NDFSM( &ndfsm_state );
traverse_NDFSM( &ndfsm_state );
// Evaluate historical test verdict
if (ndfsm_state.fatal_failure)
{
verdict = false;
testVerdict = TD_faulted;
}
else if (ndfsm_state.failure_number > 0)
{
verdict = false;
testVerdict = TD_bad_verdict;
}
else
testVerdict = TD_ok;
}
if (test->finish != NULL)
{
// Trace pseudo transition start
was_accidental_transition_traced = setTraceAccidental(true);
traceTransitionStart("finalize");
traceScenarioValue ("scenario method", "", "", "finalize");
// Call 'finish' function
clearOracleVerdict();
test->finish();
verdict = verdict && getOracleVerdict();
// Frame end
verdict = onFrameEnd( &ndfsm_state.executor.model_state, verdict );
// Trace pseudo transition end
traceTransitionEnd();
traceState("end");
traceScenarioValue ("state", "", "", "end");
setTraceAccidental(was_accidental_transition_traced);
}
}
traceScenarioEnd();
setCurrentTestScenarioName(NULL);
// Deallocate resources
destroy_NDFSM_TestEngineData( &ndfsm_state );
END_EXCEPTION_PROTECTED_SECTION();
// Stop tracing if it was started here
if (tracing_was_started_here)
{
endTrace();
ts_restore_assert_function(prev_assert);
}
// Disable standard parameters
disableStandardParameters(pars);
return verdict;
}
