int main( int argc, char *argv[] ) {
if ( PIN_Init( argc, argv ) ) {
return Usage();
}
PIN_InitSymbols();
initRcdcSim();
IMG_AddInstrumentFunction( instrumentImage, NULL );
TRACE_AddInstrumentFunction( instrumentTrace, NULL );
cerr << " Before this function\n";
//INS_AddInstrumentFunction(Instruction, 0);
cerr << " After this function\n";
PIN_AddThreadStartFunction( threadBegin, NULL );
PIN_AddThreadFiniFunction( threadEnd, NULL );
PIN_AddContextChangeFunction( beforeSignal, NULL );
PIN_AddSyscallEntryFunction( beforeSyscall, NULL );
PIN_AddSyscallExitFunction( afterSyscall, NULL );
PIN_AddFiniUnlockedFunction( pinFini, NULL );
if ( !CODECACHE_ChangeMaxInsPerTrace( 4096 * 1024 ) ) {
fprintf( stderr, "TLSProf::CODECACHE_ChangeMaxInsPerTrace failed.\n" );
}
THREADID tid = PIN_SpawnInternalThread( ioThread, NULL, 0, &s_IOThreadId );
assert( tid != INVALID_THREADID );
PIN_StartProgram();
return 0;
}
int main(int argc, char **argv)
{
PIN_Init(argc,argv);
INS_AddInstrumentFunction(insCallback, 0);
intTid = PIN_SpawnInternalThread(doPause, 0, 0, 0);
ASSERT(intTid != INVALID_THREADID, "Fail to spawn internal thread");
PIN_StartProgram();
return 0;
}
int main(int argc, char *argv[])
{
// Initialize PIN library. Print help message if -h(elp) is specified
// in the command line or the command line is invalid
if(PIN_Init(argc,argv))
return Usage();
/// Instrumentations
// Register function to be called to instrument traces
TRACE_AddInstrumentFunction(trace_instrumentation, 0);
// Register function to be called when the application exits
PIN_AddFiniFunction(this_is_the_end, 0);
// Register function to be called when a module is loaded
IMG_AddInstrumentFunction(image_instrumentation, 0);
/// Other stuffs
// This routine will be called if the sleeping_thread calls PIN_Detach() (when the time is out)
PIN_AddDetachFunction(pin_is_detached, 0);
// Run a thread that will wait for the time out
PIN_SpawnInternalThread(
sleeping_thread,
0,
0,
NULL
);
// If we are in a wow64 process we must blacklist manually the JMP FAR: stub
// from being instrumented (each time a syscall is called, it will be instrumented for *nothing*)
// Its address is in FS:[0xC0] on Windows 7
ADDRINT wow64stub = __readfsdword(0xC0);
modules_blacklisted.insert(
std::make_pair(
std::string("wow64stub"),
std::make_pair(
wow64stub,
wow64stub
)
)
);
/// FIRE IN THE HOLE
// Start the program, never returns
PIN_StartProgram();
return 0;
}
Thread::State Thread::start (size_t stack_size)
{
// Prevent multiple threads from calling this routine at the same
// time and causing a race condition.
Write_Guard <RW_Mutex> guard (this->rw_mutex_);
// Make sure the thread is not already started.
if (this->state_ == STARTED || this->state_ == RUNNING)
return this->state_;
// We can start the thread.
this->thr_id_ = PIN_SpawnInternalThread (&Thread::__thr_run, this, stack_size, &this->thr_uid_);
this->state_ = this->thr_id_ != INVALID_THREADID ? STARTED : ERROR;
return this->state_;
}
int pintoolInit()
{
int returnValue = INIT_ERROR;
// option du pintool('taint' ou 'checkscore')
g_option = KOption.Value();
/**** OPTION TAINT ***/
if ("taint" == g_option)
{
returnValue = OPTION_TAINT;
// instanciation des classes globales : marquage mémoire et formule SMT2
pTmgrGlobal = new TaintManager_Global;
g_pFormula = new TranslateIR;
if (!pTmgrGlobal || !g_pFormula) return (INIT_ERROR);
/*** RECUPERATION DES ARGUMENTS DE LA LIGNE DE COMMANDE ***/
// 1) si pipe => ouverture, sinon récupération de l'option 'input'
g_nopipe = KNoPipe.Value();
if (!g_nopipe)
{
// erreur si pipe ne peut pas être ouvert
if (EXIT_FAILURE == openPipe()) return (INIT_ERROR);
// récupération de l'entrée étudiée via le pipe
g_inputFile = readFromPipe();
if (g_inputFile.empty()) return (INIT_ERROR);
}
else
{
// si pas de pipe, nom de l'entrée passée par ligne de commande
g_inputFile = KInputFile.Value();
// l'écriture des resultats (formule SMT2) se fera dans un fichier
// donc récupérer le handle du fichier qui sera utilisé
std::string formulaFile(g_inputFile + "_formula.smt2");
g_hPipe = WINDOWS::CreateFile(
formulaFile.c_str(), // nom du fichier
GENERIC_WRITE, // acces en ecriture
0, // pas de partage
nullptr, // attributs de sécurité par défaut
CREATE_ALWAYS, // écrasement du précédent fichier, si existant
0, // attributs par défaut
nullptr); // pas de modèle
if ((HANDLE)(WINDOWS::LONG_PTR) (-1) == g_hPipe) return (INIT_ERROR);
}
// 2) mode verbeux : création des fichiers de log
g_verbose = KVerbose.Value();
if (g_verbose)
{
// création et ouverture du fichier de log dessasemblage
std::string logfile(g_inputFile + "_asm.log");
g_debug.open(logfile);
// création et ouverture du fichier de log de marquage
std::string taintfile(g_inputFile + "_taint.log");
g_taint.open(taintfile);
if (!g_taint.good() || !g_debug.good()) return (INIT_ERROR);
// stockage de l'heure du top départ pour statistiques
g_timeBegin = clock();
}
// 4) intervalles d'octets source à marquer, si option présente
if (!KBytes.Value().empty()) pTmgrGlobal->setBytesToTaint(KBytes.Value());
// 5) nombre maximal de contraintes ((0 si aucune)
g_maxConstraints = KMaxConstr.Value();
// 6) type d'OS hote (déterminé par le programme appelant)
g_osType = static_cast<OSTYPE>(KOsType.Value());
// détermination des numéros de syscalls à monitorer (dépend de l'OS)
if (HOST_UNKNOWN == g_osType) return (INIT_ERROR);
else SYSCALLS::defineSyscallsNumbers(g_osType);
// initialisation de variable globale indiquant le départ de l'instrumentation
// est mise à vrai par la partie syscalls lorsque les premières données
// marquées sont créées (= lecture dans l'entrée)
g_beginInstrumentationOfInstructions = false;
// création des clefs pour les TLS, pas de fonction de destruction
g_tlsKeyTaint = PIN_CreateThreadDataKey(nullptr);
g_tlsKeySyscallData = PIN_CreateThreadDataKey(nullptr);
}
else if ("checkscore" == g_option) // option....checkscore :)
{
// erreur si pipe ne peut pas être ouvert
if (EXIT_FAILURE == openPipe()) return (INIT_ERROR);
returnValue = OPTION_CHECKSCORE;
}
else return (INIT_ERROR); // option inconnue : erreur
/**** DERNIERES INITIALISATIONS COMMUNES AUX DEUX OPTIONS **/
// Initialisation des verrous pour le multithreading
PIN_InitLock(&g_lock);
// temps maximal d'exécution (valable en 'taint' et en 'checkscore')
g_maxTime = KMaxTime.Value();
// si non nul, création d'un thread interne au pintool :
// sert à la surveillance du temps maximal d'execution
if (g_maxTime)
{
THREADID tid = PIN_SpawnInternalThread(maxTimeThread, nullptr, 0, nullptr);
if (INVALID_THREADID == tid) return (INIT_ERROR);
}
return (returnValue); // option choisie (taint ou checkScore), ou erreur d'init
} // pintoolInit()
void Scheduler::startWatchdogThread() {
PIN_SpawnInternalThread(threadTrampoline, this, 64*1024, nullptr);
}
