Exemple #1
0
void InstructionTrace(INS ins, void* v)
{
	// check if we just received a snapshot request
	bool snapshotStatus = CheckSnapshotEvent();
	if (snapshotStatus)
	{
		// We just detected a monitoring change! Take a memory snapshot now
		TakeSnapshot();

		// reset the event
		DisableSnapshotEvent();
	}

	// check the monitoring event if we should still be monitoring or not 
	bool monitoringStatus = CheckMonitoringEvent();
	if (!monitoringStatus)
	{
		return;
	}

	instruction_trace trace;
	trace.tid = PIN_GetTid();
	trace.address = INS_Address(ins);

	memset(trace.library_name, 0, 260);
	std::string libraryName;
	if (CHECK_LIBRARY_NAMES && GetLibraryName(trace.address, libraryName))
	{
		snprintf(trace.library_name, sizeof(trace.library_name), "%s", libraryName.c_str());
	}
	

	if (INS_IsCall(ins) == true)
	{
		trace.execution_depth = executionDepth++;
	}
	else if (INS_IsRet(ins) == true)
	{
		trace.execution_depth = executionDepth--;
	}
	else
		trace.execution_depth = executionDepth;

	trace.instruction_count = instructionCount++;
	
#ifdef TARGET_WINDOWS
	trace.execution_time = WINDOWS::GetTickCount();
#else
	timeval time;
	gettimeofday(&time, NULL);
	unsigned long millis = (time.tv_sec * 1000) + (time.tv_usec / 1000);
	trace.execution_time = millis;
#endif

	LogStruct(trace);
}
Exemple #2
0
void m_dump_bytes(const void *bytes, size_t size) {
	if(standard_out) {
		return;
	}

	FILE *file;
	char temp[1000];
	sprintf(temp, "%s.mtrace.byte_dump.%u", KnobOutputFile.Value().c_str(), PIN_GetTid());

	file = fopen(temp, "a");
	fwrite(bytes, size, 1, file);
	fflush(file);
	fclose(file);
}
Exemple #3
0
void output_dummy_stacktrace() {
	FILE *file;

	if(standard_out) {
		file = stdout;
	} else {
		char temp[1000];
		sprintf(temp, "%s.mtrace.stackinfo.%u", KnobOutputFile.Value().c_str(), PIN_GetTid());
		file = fopen(temp, "a");
	}

	fprintf(file, "[]\n");

	fflush(file);
	fclose(file);
}
Exemple #4
0
VOID ThreadStart(THREADID threadid, CONTEXT *ctxt, INT32 flags, VOID *v)
{
    PIN_InitLock(&lock);
    PIN_GetLock(&lock, threadid+1);
    numThreads++;
    if (threadid > maxThreads)
        maxThreads = threadid;

    OS_THREAD_ID oid = PIN_GetTid();
    OSTID_ITER iter = tidMap.find(oid);
    if (iter == tidMap.end())
    {
        // new threads
        numSysThreads++;
        tidMap.insert(oid);
    }
    PIN_ReleaseLock(&lock);
}
Exemple #5
0
Thread * Thread::current (void)
{
  // Get the current thread in TLS, and return if exists.
  THREADID thr_id = PIN_ThreadId ();
  Thread * thr = Thread::current_.get (thr_id);
  
  if (0 != thr)
    return thr;
  
  // This could be the main thread, which does not have an Thread object
  // in the TLS. So, create a new thread, and store it.
  thr = new Thread (thr_id,
                    PIN_GetTid (),
                    PIN_ThreadUid (),
                    PIN_GetParentTid ());
  
  Thread::current_.set (thr_id, thr);
  return thr;
}
Exemple #6
0
void mprintf(const char *format, ...) {
	FILE *file;

	if(standard_out) {
		file = stdout;
	} else {
		char temp[1000];
		sprintf(temp, "%s.mtrace.%u", KnobOutputFile.Value().c_str(), PIN_GetTid());
		file = fopen(temp, "a");
	}

	
	va_list ap;
	va_start(ap, format);
	vfprintf(file, format, ap);
	va_end(ap);

	fflush(file);
	fclose(file);
}
Exemple #7
0
void output_stacktrace() {
	FILE *file;

	if(standard_out) {
		file = stdout;
	} else {
		char temp[1000];
		sprintf(temp, "%s.mtrace.stackinfo.%u", KnobOutputFile.Value().c_str(), PIN_GetTid());
		file = fopen(temp, "a");
	}

	assert(file != NULL);

	static int initialized = 0;
	static void (*actual_function)(FILE *) = NULL;
	if(initialized == 0) {
		char *errors;
		char temp[1000];
		void *dl_handle;

		sprintf(temp, "%s/libstacktrace.so", getenv("MTRACE_HOME"));

		errors = dlerror(); if(errors != NULL) printf("%s\n", errors);
		dlopen("libunwind.so", RTLD_NOW | RTLD_GLOBAL);
		errors = dlerror(); if(errors != NULL) printf("%s\n", errors);
		dl_handle = dlopen(temp, RTLD_NOW | RTLD_GLOBAL);
		errors = dlerror(); if(errors != NULL) printf("%s\n", errors);

		actual_function = (void(*)(FILE*)) dlsym(dl_handle, "output_stacktrace");
		assert(actual_function != NULL);

		initialized = 1;
	}
	assert(actual_function != NULL);
	(*actual_function)(file);

	fflush(file);
	fclose(file);
}
Exemple #8
0
VOID SyscallEntry(THREADID threadIndex, CONTEXT *ctxt, SYSCALL_STANDARD std, VOID *v)
{
	flush_mwrite(threadIndex);

	ADDRINT num = PIN_GetSyscallNumber(ctxt, std);

	if(num == SYS_execve) {	
		PrintTime(NULL);
		output_dummy_stacktrace();
		mprintf("mtrace_execve(%ld, %u, %u, %u, %u) = 0\n", syscall(SYS_gettid), PIN_GetTid(), getpid(), threadIndex, PIN_ThreadId());
		m_dump_bytes(NULL, 0);
		return;
	}

	if (num != SYS_mmap && num != SYS_munmap) {
		thread_to_syscall[threadIndex].ip = 0;
		return;
	}


	thread_to_syscall[threadIndex].num = num;
	thread_to_syscall[threadIndex].ip = PIN_GetContextReg(ctxt, REG_INST_PTR);

	if(num == SYS_mmap) {
		for(int i = 0; i < 6; i++) {
			#if defined(TARGET_LINUX) && defined(TARGET_IA32)
			thread_to_syscall[threadIndex].args[i] =
				(reinterpret_cast<ADDRINT *>(PIN_GetSyscallArgument(ctxt, std, 0)))[i];
			#else
			thread_to_syscall[threadIndex].args[i] = PIN_GetSyscallArgument(ctxt, std, i);
			#endif
		}
	} else {
		for(int i = 0; i < 2; i++) {
			thread_to_syscall[threadIndex].args[i] = PIN_GetSyscallArgument(ctxt, std, i);
		}
	}
}
Exemple #9
0
VOID Thread::__thr_run (VOID * arg)
{
  // Get the thread object, and update its remaining attributes.
  Thread * thr = reinterpret_cast <Thread *> (arg);
  
  // Set the current thread to the Thread object. This allows the
  // client to access the Thread object via the current () method.
  Thread::current_.set (thr->thr_id_, thr);
  
  do
  {
    Write_Guard <RW_Mutex> guard (thr->rw_mutex_);
    thr->os_thr_id_ = PIN_GetTid ();
    thr->parent_os_thr_id_ = PIN_GetParentTid ();
    
    // Set the state to running.
    thr->state_ = RUNNING;
  } while (0);

  // Determine what run method we should invoke. Either we invoke the run()
  // method on the runnable_ object contained in the thread, or we invoke
  // the run() method on the thread. The runnable_ variable takes precedence
  // over the run() method on the Thread.
  Runnable * runnable = thr->runnable_;

  if (0 == runnable)
    runnable = thr;

  runnable->run ();

  do
  {
    // Reset the thread state.
    Write_Guard <RW_Mutex> guard (thr->rw_mutex_);
    thr->state_ = TERMINATED;
  } while (0);
}
Exemple #10
0
VOID ThreadFini(THREADID threadid, const CONTEXT *ctxt, INT32 code, VOID *v)
{
    PIN_GetLock(&lock, PIN_GetTid());
    threadEnded++;
    PIN_ReleaseLock(&lock);
}
Exemple #11
0
VOID ThreadStart(THREADID threadid, CONTEXT *ctxt, INT32 flags, VOID *v)
{
    PIN_GetLock(&lock, PIN_GetTid());
    threadCreated++;
    PIN_ReleaseLock(&lock);
}
Exemple #12
0
VOID AppStart(VOID *v)
{
    father_id = PIN_GetTid();
    PRINT_ME_AND_MY_FATHER();
    TEST(father_id != INVALID_OS_THREAD_ID, "PIN_GetTid failed");
}
Exemple #13
0
VOID AfterForkInChild(THREADID threadid, const CONTEXT* ctxt, VOID * arg) {
	PrintTime(NULL);
	output_dummy_stacktrace();
	mprintf("mtrace_fork_child(%ld, %u, %u, %u, %u) = 0\n", syscall(SYS_gettid), PIN_GetTid(), getpid(), threadid, PIN_ThreadId());
	m_dump_bytes(NULL, 0);
}
Exemple #14
0
VOID ThreadStart(THREADID threadid, CONTEXT *ctxt, INT32 flags, VOID *v) {
	PrintTime(NULL);
	output_dummy_stacktrace();
	mprintf("mtrace_thread_start(%u, %u, %u, %u, %u) = 0\n", syscall(SYS_gettid), PIN_GetTid(), getpid(), threadid, PIN_ThreadId());
	m_dump_bytes(NULL, 0);
}