// ------------------------------------------------------------- // Thread start function // ------------------------------------------------------------- VOID ThreadStart(THREADID threadid, CONTEXT *ctxt, INT32 flags, VOID *v) { // create local thread data _STool_TThreadRec* tdata = (_STool_TThreadRec*)malloc(sizeof(_STool_TThreadRec) + gSetup.threadRecSize); if (tdata == NULL) panic(threadid, "Can't allocate thread specific info"); // init local thread data tdata->threadID = threadid; tdata->stackTop = 0; tdata->stackMaxSize = INIT_STACK; // create initial shadow activation stack tdata->activationStack = (_STool_TActivationRec*)malloc(tdata->stackMaxSize*sizeof(_STool_TActivationRec)); if (tdata->activationStack == NULL) panic(threadid, "Can't allocate shadow activation stack"); // create initial user stack (if any was requested by the analysis tool) if (gSetup.activationRecSize > 0) { tdata->userStack = (char*)malloc(tdata->stackMaxSize*gSetup.activationRecSize); if (tdata->userStack == NULL) panic(threadid, "Can't allocate user stack"); } else tdata->userStack = NULL; // if using memory operations buffering, initialize trace buffer pointer if (gSetup.memBuf) tdata->buf_addr = PIN_GetBufferPointer(ctxt, buf_id); // call thread start callback (if any was specified by the analysis tool) if (gSetup.threadStart) gSetup.threadStart(tdata + 1); // associate thread-specific data to thread PIN_SetThreadData(gTlsKey, tdata, threadid); }
/* * thread start callback (analysis function) * * allocate space for the syscall context and VCPUs * (i.e., thread context), and set the TLS-like pointer * (i.e., thread_ctx_ptr) accordingly * * @tid: thread id * @ctx: CPU context * @flags: OS specific flags for the new thread * @v: callback value */ static void thread_alloc(THREADID tid, CONTEXT *ctx, INT32 flags, VOID *v) { /* thread context pointer (ptr) */ thread_ctx_t *tctx = NULL; /* allocate space for the thread context; optimized branch */ if (unlikely((tctx = (thread_ctx_t *)calloc(1, sizeof(thread_ctx_t))) == NULL)) { /* error message */ LOG(string(__func__) + ": thread_ctx_t allocation failed (" + string(strerror(errno)) + ")\n"); /* die */ libdft_die(); } /* save the address of the per-thread context to the spilled register */ PIN_SetContextReg(ctx, thread_ctx_ptr, (ADDRINT)tctx); char fileName[256]; sprintf(fileName, "C:\\itrace_thread%u.txt", tid); thread_local *t_local = new thread_local; t_local->insaddr = 0; t_local->logfile = fopen(fileName, "w"); PIN_SetThreadData(trace_tls_key, t_local, tid); }
VOID ThreadFini(THREADID threadid, const CONTEXT *ctxt, INT32 flags, VOID *v) { if(threadid!=0)return; delete tdata; tdata=NULL; PIN_SetThreadData(tls_key, NULL, threadid); }
/* * Note that opening a file in a callback is only supported on Linux systems. * See buffer-win.cpp for how to work around this issue on Windows. */ VOID ThreadStart(THREADID tid, CONTEXT *ctxt, INT32 flags, VOID *v) { // There is a new MLOG for every thread. Opens the output file. MLOG * mlog = new MLOG(tid); // A thread will need to look up its MLOG, so save pointer in TLS PIN_SetThreadData(mlog_key, mlog, tid); }
VOID ThreadFini(THREADID tid, const CONTEXT *ctxt, INT32 code, VOID *v) { MLOG * mlog = static_cast<MLOG*>(PIN_GetThreadData(mlog_key, tid)); cout << "Count[" << decstr(tid) << "]= " << mlog->_icount << endl; cout << "Total count[" << decstr(tid) << "]= " << mlog->_total << endl; delete mlog; PIN_SetThreadData(mlog_key, 0, tid); }
VOID ThreadStart(THREADID threadid, CONTEXT *ctxt, INT32 flags, VOID *v) { GetLock(&lock, threadid+1); numThreads++; ReleaseLock(&lock); thread_data_t* tdata = new thread_data_t; PIN_SetThreadData(tls_key, tdata, threadid); }
VOID ThreadStart(THREADID threadid, CONTEXT *ctxt, INT32 flags, VOID *v) { if(threadid!=0)return; PIN_GetLock(&lock, threadid+1); numThreads++; PIN_ReleaseLock(&lock); tdata = new thread_data_t (threadid); PIN_SetThreadData(tls_key, tdata, threadid); }
VOID ThreadStart(THREADID threadid, CONTEXT *ctxt, INT32 flags, VOID *v) { PIN_GetLock(&lock, 0); thread_data *td = new thread_data; PIN_SetThreadData(tls_key, td, threadid); all_thread_data.push_back(td); PIN_ReleaseLock(&lock); }
VOID ThreadStart(THREADID threadid, CONTEXT *ctxt, INT32 flags, VOID *v) { PIN_GetLock(&lock, threadid+1); numThreads++; PIN_ReleaseLock(&lock); thread_data_t* tdata = new thread_data_t; clock_gettime(CLOCK_MONOTONIC, &tdata->tstart); PIN_SetThreadData(tls_key, tdata, threadid); }
static void thread_start(THREADID tid, CONTEXT *ctxt, INT32 flags, VOID *v) { sse_aligner_t *pthis = static_cast<sse_aligner_t *>(v); if (pthis->verbose) *(pthis->out) << "thead begin " << static_cast<uint32_t>(tid) << endl; // This function is locked no need for a Pin Lock here pthis->num_threads++; pthis->active_threads++; thread_data_t* tdata = new thread_data_t; // remember my pointer for later PIN_SetThreadData(pthis->tls_key, tdata, tid); }
/* * thread finish callback (analysis function) * * free the space for the syscall context and VCPUs * * @tid: thread id * @ctx: CPU context * @code: OS specific termination code for the thread * @v: callback value */ static void thread_free(THREADID tid, const CONTEXT *ctx, INT32 code, VOID *v) { /* get the thread context */ thread_ctx_t *tctx = (thread_ctx_t *) PIN_GetContextReg(ctx, thread_ctx_ptr); /* free the allocated space */ free(tctx); thread_local *t_local = (thread_local *)PIN_GetThreadData(trace_tls_key, tid); PIN_SetThreadData(trace_tls_key, NULL, tid); fflush(t_local->logfile); fclose(t_local->logfile); delete(t_local); }
VOID ThreadStart( THREADID tid, CONTEXT *ctxt, INT32 flags, VOID *v) { PIN_GetLock(&lock, tid+1); tIds[numThreads] = tid; stringstream fn; if ( tid != numThreads ) { cout << " TID NOT SAME AS NUMTHREADS " << tid << " " << numThreads << endl; } fn.str(""); fn << OUT_FILE << "_" << numThreads; OutFile[numThreads].open(fn.str().c_str(), ios::out); ++numThreads; PIN_ReleaseLock(&lock); thread_data_t *tdata = new thread_data_t(numThreads-1); PIN_SetThreadData(tls_key, tdata, tid); }
VOID ThreadStart( THREADID tid, CONTEXT *ctxt, INT32 flags, VOID *v) { PIN_GetLock(&lock, tid+1); tIds[numThreads] = tid; stringstream fn; /* If you ever see this then change the logic in code which uses tid to index into open File streams to do File I/O */ if ( tid != numThreads ) { cout << " TID NOT SAME AS NUMTHREADS " << tid << " " << numThreads << endl; } fn.str(""); fn << OUT_FILE << "_" << numThreads; OutFile[numThreads].open(fn.str().c_str(), ios::out); ++numThreads; PIN_ReleaseLock(&lock); thread_data_t *tdata = new thread_data_t(numThreads-1); PIN_SetThreadData(tls_key, tdata, tid); }
void ThreadStart(THREADID tid, CONTEXT * context, int flags, void * v) { // We check that we got the right thing in the buffer full callback PIN_SetThreadData(buf_key, PIN_GetBufferPointer(context, bufId), tid); }
VOID SaveEa(THREADID tid, VOID * ea) { PIN_SetThreadData(ea_tls_key, ea, tid); }
// PIN_SetThreadData and PIN_GetThreadData are overloaded, // hence we use a detour to get a single function pointer static BOOL PIN_SetThreadData_detour( TLS_KEY key, const void *data, THREADID thread_id) { return PIN_SetThreadData(key, data, thread_id); }