Update copyright to LGPL on all files
[dyninst.git] / dyninstAPI / src / BPatch_thread.C
1 /*
2  * Copyright (c) 1996-2009 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30  */
31
32 #define BPATCH_FILE
33
34 #include "BPatch_thread.h"
35 #include "BPatch.h"
36 #include "BPatch_libInfo.h"
37 #include "BPatch_function.h"
38 #include "process.h"
39 #include "signalgenerator.h"
40 #include "mailbox.h"
41 #include "dyn_thread.h"
42 #include "dyn_lwp.h"
43 #include "BPatch_libInfo.h"
44 #include "function.h"
45 #include "BPatch_statement.h"
46
47 #if defined(IBM_BPATCH_COMPAT)
48 #include <algorithm>
49 #endif
50
51 /*
52  * BPatch_thread::getCallStack
53  *
54  * Returns information about the frames currently on the thread's stack.
55  *
56  * stack        The vector to fill with the stack trace information.
57  */
58 bool BPatch_thread::getCallStackInt(BPatch_Vector<BPatch_frame>& stack)
59 {
60    pdvector<Frame> stackWalk;   
61
62    if (!llthread->walkStack(stackWalk) ) {
63      fprintf(stderr, "%s[%d]: ERROR doing stackwalk\n", FILE__, __LINE__);
64    }
65
66    // The internal representation of a stack walk treats instrumentation
67    // as part of the original instrumented function. That is to say, if A() 
68    // calls B(), and B() is instrumented, the stack will appear as so:
69    // A()
70    // instrumentation
71
72    // We want it to look like so:
73    // A()
74    // B()
75    // instrumentation
76
77    // We handle this by adding a synthetic frame to the stack walk whenever
78    // we discover an instrumentation frame.
79
80    for (unsigned int i = 0; i < stackWalk.size(); i++) {
81       bool isSignalFrame = false;
82       bool isInstrumentation = false;
83       BPatch_point *point = NULL;
84
85       Frame frame = stackWalk[i];
86       frame.calcFrameType();
87       if (frame.frameType_ != FRAME_unset) {
88          isSignalFrame = frame.isSignalFrame();
89          isInstrumentation = frame.isInstrumentation();
90       }
91
92       if (isInstrumentation) {
93          // This is a bit of a slog, actually. We want to only show
94          // bpatch points that exist, not describe internals to the
95          // user. So instead of calling findOrCreateBPPoint, we manually
96          // poke through the mapping table. If there isn't a point, we
97          // skip this instrumentation frame instead
98          instPoint *iP = frame.getPoint();
99          if (iP) {
100             point = proc->findOrCreateBPPoint(NULL, iP);
101          }
102          if (point) {
103             stack.push_back(BPatch_frame(this,
104                                          (void*)stackWalk[i].getPC(),
105                                          (void*)stackWalk[i].getFP(),
106                                          false,
107                                          true,
108                                          point));
109             // And the "top-level function" one.
110             stack.push_back(BPatch_frame(this,
111                                          (void *)stackWalk[i].getUninstAddr(),
112                                          (void *)stackWalk[i].getFP(),
113                                          false, // not signal handler,
114                                          false, // not inst.
115                                          NULL, // No point
116                                          true)); // Synthesized frame
117          }
118          else {
119             // No point = internal instrumentation, make it go away.
120             stack.push_back(BPatch_frame(this,
121                                          (void *)stackWalk[i].getUninstAddr(),
122                                          (void *)stackWalk[i].getFP(),
123                                          false, // not signal handler,
124                                          false, // not inst.
125                                          NULL, // No point
126                                          false)); // Synthesized frame
127                 
128          }
129       }
130       else {
131          // Not instrumentation, normal case
132          stack.push_back(BPatch_frame(this,
133                                       (void *)stackWalk[i].getPC(),
134                                       (void *)stackWalk[i].getFP(),
135                                       isSignalFrame));
136       }
137    }
138    return true;
139 }
140
141 BPatch_thread *BPatch_thread::createNewThread(BPatch_process *proc, 
142                                               int ind, int lwp_id, dynthread_t async_tid)
143 {
144    BPatch_thread *newthr;
145    newthr = new BPatch_thread(proc, ind, lwp_id, async_tid);
146    return newthr;
147 }
148
149 BPatch_thread::BPatch_thread(BPatch_process *parent, int ind, int lwp_id, dynthread_t async_tid) :
150     deleted_callback_made(false)
151 {
152    proc = parent;
153    legacy_destructor = true;
154    updated = false;
155    reported_to_user = false;
156    index = (unsigned) -1; // is this safe ??  might want index = -1??
157    is_deleted = false;
158    doa_tid = (dynthread_t) -1;
159    dyn_lwp *lwp = NULL;
160
161    llthread = proc->llproc->getThread(async_tid);
162 #if defined(os_windows)
163   //On Windows the initial LWP has two possible handles, one associated
164   // with the thread and one associated with the process.  We use the
165   // process handle in Dyninst, so we don't want to use the thread-based
166   // lwp_id that got passed in.
167   if (!ind)
168       lwp = proc->llproc->getInitialLwp();
169 #endif
170    if (llthread && llthread->get_lwp())
171       lwp = llthread->get_lwp();
172    else if (!lwp)
173       lwp = proc->llproc->getLWP(lwp_id);
174
175    if (lwp == NULL) {
176      doa = true;
177    } 
178    else if (lwp->is_dead()) {
179      doa = true;
180    }
181    else doa = false;
182
183    doa_tid = async_tid;
184    if (doa) {
185       is_deleted = true;
186       llthread = NULL;
187       return;
188    }
189
190    if (!llthread)
191        llthread = new dyn_thread(proc->llproc, ind, lwp);
192
193    if (llthread->get_index() == -1 && ind != -1)
194        proc->llproc->updateThreadIndex(llthread, ind);
195
196    index = llthread->get_index();
197
198 }
199
200 BPatch_thread::BPatch_thread(BPatch_process *parent, dyn_thread *dthr) :
201     deleted_callback_made(false)
202 {
203    doa = false;
204    doa_tid = (dynthread_t) -1;
205    is_deleted = false;
206    index = 0;
207    proc = parent;
208    llthread = dthr;
209    legacy_destructor = true;
210    updated = false;
211    reported_to_user = false;
212 }
213
214 void BPatch_thread::updateValues(dynthread_t tid, unsigned long stack_start,
215                                  BPatch_function *initial_func, int lwp_id)
216 {
217    dyn_lwp *lwp = NULL;
218    if (updated) {
219      //fprintf(stderr, "%s[%d]:  thread already updated\n", FILE__, __LINE__);
220      return;
221    }
222
223 #if defined(os_windows)
224   //On Windows the initial LWP has two possible handles, one associated
225   // with the thread and one associated with the process.  We use the
226   // process handle in Dyninst, so we don't want to use the thread-based
227   // lwp_id that got passed in.
228   if (!index)
229       lwp = proc->llproc->getInitialLwp();
230 #endif
231 #if !defined(cap_proc_fd)
232    if (llthread && llthread->get_lwp())
233        lwp = llthread->get_lwp();
234 #endif
235    // For solaris-style /proc we _always_ use the process-grabbed
236    // LWP. Thread 1 is created with the representative LWP initially,
237    // and then needs to be updated.
238    if (!lwp)
239        lwp = proc->llproc->getLWP(lwp_id);
240
241    updated = true;
242    if (stack_start && !llthread->get_stack_addr())
243        llthread->update_stack_addr(stack_start);
244    if (lwp && 
245        ((llthread->get_lwp() == NULL) ||
246         (llthread->get_lwp() == proc->llproc->getRepresentativeLWP())))
247        llthread->update_lwp(lwp);
248
249    if (!llthread->get_tid()) {
250        if (tid == -1) {
251            //Expensive... uses an iRPC to get it from the RT library
252            tid = proc->llproc->mapIndexToTid(index);   
253        }
254        llthread->update_tid(tid);
255    }
256    
257    //If initial_func or stack_start aren't provided then
258    // we can update them with a stack walk
259    // We delay this to speed initialization -- the main thread
260    // never comes in with info, which triggers a.out parsing.
261
262    if (initial_func && !llthread->get_start_func())
263    {
264       llthread->update_start_func(initial_func->func);
265    }
266 }
267
268 unsigned BPatch_thread::getBPatchIDInt()
269 {
270    return index;
271 }
272
273 BPatch_process *BPatch_thread::getProcessInt() 
274 {
275    return proc;
276 }
277
278 dynthread_t BPatch_thread::getTidInt()
279 {
280    if (doa || is_deleted) {
281       return doa_tid/*(dynthread_t) -1*/;
282    }
283    return llthread->get_tid();
284 }
285
286 int BPatch_thread::getLWPInt()
287 {
288    if (doa || is_deleted) {
289       return (int) -1;
290    }
291    return llthread->get_lwp()->get_lwp_id();
292 }
293
294 BPatch_function *BPatch_thread::getInitialFuncInt()
295 {
296    if (doa || is_deleted) {
297       return NULL;
298    }
299    int_function *ifunc = llthread->get_start_func();
300
301    if (!ifunc && llthread->get_indirect_start_addr())
302    {
303       //Currently should only be true on IA-64
304       process *llproc = getProcess()->llproc;
305       Address func_struct = llthread->get_indirect_start_addr();
306       Address functionEntry = 0;
307       bool readDataSpace = llproc->readDataSpace((void *) func_struct, 
308                                                  sizeof(Address), 
309                                                  &functionEntry, false);
310       if( readDataSpace ) {
311          ifunc = llproc->findFuncByAddr(functionEntry);
312          llthread->update_start_func(ifunc);
313       }
314    }
315
316    if (!ifunc) {
317        BPatch_Vector<BPatch_frame> stackWalk;
318
319        getCallStackInt(stackWalk);
320
321        unsigned long stack_start = 0;
322        BPatch_function *initial_func = NULL;
323        
324        int pos = stackWalk.size() - 1;
325
326 #if defined(DEBUG)
327        for (unsigned foo = 0; foo < stackWalk.size(); foo++) {
328          BPatch_function *func = stackWalk[foo].findFunction();
329          fprintf(stderr, "Function at %d is %s\n", foo, func ? func->lowlevel_func()->symTabName().c_str() : "<NULL>");
330        }
331 #endif
332
333        //Consider stack_start as starting at the first
334        //function with a stack frame.
335        while ((!stack_start || !initial_func) && (pos >= 0)) {
336            if (!stack_start) {
337                stack_start = (unsigned long) stackWalk[pos].getFP();
338            }
339            if (!initial_func) {
340                BPatch_function *func = stackWalk[pos].findFunction();
341                BPatch_module *mod = func ? func->getModule() : NULL;
342                if (mod && !mod->isSystemLib())
343                    initial_func = func;        
344            }
345            pos--;
346        }
347        
348 #if defined(os_linux)
349        // RH9 once again does it half-right.  The "initial function" by our
350        // heuristics is start_thread, but in reality is actually the called
351        // function of this frame.
352        
353        if (initial_func && pos >= 0) {
354           // Check if function is in libpthread
355           char mname[2048], fname[2048], pfname[2048];
356           initial_func->getModule()->getName(mname, 2048);
357           initial_func->getName(fname, 2048);
358           if (strstr(mname, "libpthread.so")) {
359              initial_func = stackWalk[pos].findFunction();
360              stack_start = (unsigned long) stackWalk[pos].getFP();
361           } else if (!strcmp(fname,"start_thread") &&
362                      pos < (int) stackWalk.size() - 2 &&
363                      stackWalk[pos+2].findFunction() &&
364                      !strcmp(stackWalk[pos+2].findFunction()->getName(pfname, 2048), "clone")) {
365              initial_func = stackWalk[pos].findFunction();
366              stack_start = (unsigned long) stackWalk[pos].getFP();
367           }
368        }
369 #endif
370
371        if (!llthread->get_stack_addr())
372            llthread->update_stack_addr(stack_start);
373        if (initial_func)
374            llthread->update_start_func(initial_func->func);
375    }
376
377    // Try again...
378    ifunc = llthread->get_start_func();
379    ifunc = llthread->map_initial_func(ifunc);
380
381    if (!ifunc) return NULL;
382
383    return proc->findOrCreateBPFunc(ifunc, NULL);
384 }
385
386 unsigned long BPatch_thread::getStackTopAddrInt()
387 {
388    if (doa || is_deleted) {
389       return (unsigned long) -1;
390    }
391    if (llthread->get_stack_addr() == 0) {
392        BPatch_Vector<BPatch_frame> stackWalk;
393
394        getCallStackInt(stackWalk);
395        unsigned long stack_start = 0;
396        BPatch_function *initial_func = NULL;
397        
398        int pos = stackWalk.size() - 1;
399        //Consider stack_start as starting at the first
400        //function with a stack frame.
401        while ((!stack_start || !initial_func) && (pos >= 0)) {
402            if (!stack_start)
403                stack_start = (unsigned long) stackWalk[pos].getFP();
404            if (!initial_func) {
405                initial_func = stackWalk[pos].findFunction();
406                if (initial_func) {
407                    char fname[2048];
408                    initial_func->getName(fname, 2048);
409                    //fprintf(stderr, "%s[%d]:  setting initial func to %s\n", FILE__, __LINE__, fname);
410                }
411            }
412            pos--;
413        }
414        llthread->update_stack_addr(stack_start);
415        if (initial_func)
416            llthread->update_start_func(initial_func->func);
417    }
418    
419    return llthread->get_stack_addr();
420 }
421
422
423 void BPatch_thread::removeThreadFromProc() 
424 {
425 #if !defined(USE_DEPRECATED_BPATCH_VECTOR)
426    // STL vectors don't have item erase. We use iterators instead...
427    proc->threads.erase(std::find(proc->threads.begin(),
428                                  proc->threads.end(),
429                                  this));
430 #else
431    for (unsigned i=0; i<proc->threads.size(); i++) {
432       if (proc->threads[i] == this) {
433          proc->threads.erase(i);
434          break;
435       }
436    }
437 #endif    
438 }
439
440 /**
441  * We can't overload destructors, and this function used to defined in
442  * the API to delete the process.  We don't know if any users are still
443  * depending on that behavior, so any regular call to this destructor
444  * will trigger the 'delete proc'
445  *    
446  * To get the "overloaded" and new destructor, set legacy_destructor
447  * to false before calling.  This should be okay since it's only used
448  * by internal code (should only be called through BPatch_process).
449  **/    
450 void BPatch_thread::BPatch_thread_dtor()
451 {
452   if (llthread)
453     removeThreadFromProc();
454   if (legacy_destructor)
455   {
456     //  ~BPatch_process obtains a lock and does a wait(), so it will fail an assert 
457     //  unless we "creatively adjust" the recursive lock depth here.
458     BPatch_process *temp = proc;
459     proc = NULL;
460     if (temp) delete temp;
461   }
462   else
463   {
464     if (llthread) {
465       dynthread_t thr  = getTid();
466       if (thr == 0) {
467         fprintf(stderr, "%s[%d]:  about to deleteThread(0)\n", FILE__, __LINE__);
468       }
469       proc->llproc->deleteThread(thr);
470     }
471   }
472 }
473
474 void BPatch_thread::deleteThread(bool cleanup) 
475 {
476    removeThreadFromProc();
477
478    dynthread_t thr = getTid();
479    if (thr == 0) {
480       signal_printf("%s[%d]:  WARN:  skipping deleteThread(0)\n", FILE__, __LINE__);
481    }
482    else if (cleanup)
483      proc->llproc->deleteThread(thr);
484    llthread = NULL;
485    is_deleted = true;
486
487    //We're intentionally hanging onto thread objects rather than
488    // deleting them, in order to allow the user to still have a handle
489    // for deleted threads.  If we change our mind on this, uncomment the
490    // following two lines:
491    //legacy_destructor = true;
492    //delete this;
493 }
494
495 /**
496  * Paradynd sometimes wants handles to the OS threads for reading timing 
497  * information.  Not sure if this should become a part of the public, 
498  * supported interface.
499  **/
500 unsigned long BPatch_thread::os_handleInt()
501 {
502    if (doa || is_deleted) {
503       return (unsigned long) -1;
504    }
505 #if !defined(os_windows)
506     // Don't need this any more; we only needed the /proc/<pid>/usage
507     // fd on Solaris, and that's opened by the daemon. Windows... I don't
508     // understand enough about the system to say.
509     assert(0);
510     return -1UL; // keep compiler happy
511 #else
512     return (unsigned long) llthread->get_lwp()->get_fd();
513 #endif
514 }
515
516 #if 0
517 // We use the one in BPatch_process, feeding it thread info...
518
519 /*
520  * BPatch_thread::oneTimeCodeInternal
521  *
522  * Causes a snippet expression to be evaluated once in the mutatee at the next
523  * available opportunity.  Optionally, Dyninst will call a callback function
524  * when the snippet has executed in the mutatee, and can wait until the
525  * snippet has executed to return.
526  *
527  * expr         The snippet to evaluate.
528  * userData     This value is given to the callback function along with the
529  *              return value for the snippet.  Can be used by the caller to
530  *              store per-oneTimeCode information.
531  * synchronous  True means wait until the snippet has executed, false means
532  *              return immediately.
533  */
534 void *BPatch_thread::oneTimeCodeInternal(const BPatch_snippet &expr,
535                                          void *userData,
536                                          bool synchronous)
537 {
538    bool needToResume = false;
539
540    signal_printf("%s[%d]: UI top of oneTimeCode (threaded)...\n", FILE__, __LINE__);
541
542    while (proc->llproc->sh->isActivelyProcessing()) {
543        signal_printf("%s[%d]:  waiting before doing user stop for process %d\n", FILE__, __LINE__, proc->llproc->getPid());
544        proc->llproc->sh->waitForEvent(evtAnyEvent);
545    }
546       
547    signal_printf("%s[%d]: oneTimeCode (threaded), handlers quiet, sync %d, statusIsStopped %d\n",
548                  FILE__, __LINE__, synchronous, proc->statusIsStopped());
549
550    if (synchronous && !proc->statusIsStopped()) {
551        assert(0); // ...
552        
553       if (!isStopped()) {
554          fprintf(stderr, "%s[%d]:  failed to run oneTimeCodeInternal .. status is %s\n", 
555                  FILE__, __LINE__, 
556                  proc->llproc ? proc->llproc->getStatusAsString().c_str() : "unavailable");
557          return NULL;
558       }
559       needToResume = true;
560    }
561
562    OneTimeCodeInfo *info = new OneTimeCodeInfo(synchronous, userData, index);
563
564    proc->llproc->getRpcMgr()->postRPCtoDo(expr.ast,
565                                           false, 
566                                           BPatch_process::oneTimeCodeCallbackDispatch,
567                                           (void *)info,
568                                           false,
569                                           llthread, NULL); 
570     
571    if (synchronous) {
572       do {
573         proc->llproc->getRpcMgr()->launchRPCs(false);
574         getMailbox()->executeCallbacks(FILE__, __LINE__);
575         if (info->isCompleted()) break;
576         proc->llproc->sh->waitForEvent(evtRPCSignal, proc->llproc, NULL /*lwp*/, statusRPCDone);
577         getMailbox()->executeCallbacks(FILE__, __LINE__);
578       } while (!info->isCompleted() && !isTerminated());
579       
580       void *ret = info->getReturnValue();
581       delete info;
582
583       if (needToResume) {
584          proc->continueExecutionInt();
585       }
586         
587       return ret;
588    } else {
589       proc->llproc->getRpcMgr()->launchRPCs(proc->llproc->status() == running);
590       return NULL;
591    }
592 }
593 #endif
594
595 /*
596  * BPatch_thread::oneTimeCode
597  *
598  * Have the mutatee execute specified code expr once.  Wait until done.
599  *
600  */
601 void *BPatch_thread::oneTimeCodeInt(const BPatch_snippet &expr, bool *err)
602 {
603   if (is_deleted)
604     return NULL;
605   return proc->oneTimeCodeInternal(expr, this, NULL, NULL, true, err);
606 }
607
608 /*
609  * BPatch_thread::oneTimeCodeAsync
610  *
611  * Have the mutatee execute specified code expr once.  Don't wait until done.
612  *
613  */
614 bool BPatch_thread::oneTimeCodeAsyncInt(const BPatch_snippet &expr, 
615                                         void *userData,
616                                         BPatchOneTimeCodeCallback cb)
617 {
618    if (proc->statusIsTerminated()) {
619       return false;
620    }
621    if (is_deleted)
622      return false;
623    proc->oneTimeCodeInternal(expr, this, userData, cb, false, NULL);
624    return true;   
625 }
626
627 bool BPatch_thread::isDeadOnArrivalInt() 
628 {
629    return doa;
630 }
631
632 /* This function should be deprecated. */
633 bool BPatch_thread::getLineAndFile( unsigned long addr, 
634                                     unsigned short & lineNo, 
635                                     char * fileName, 
636                                     int length ) 
637 {
638    BPatch_Vector< BPatch_statement > lines;
639    if ( ! getSourceLines( addr, lines ) ) { return false; }
640         
641    if ( lines.size() > 0 ) {
642       lineNo = (unsigned short) lines[0].lineNumber();
643       strncpy( fileName, lines[0].fileName(), length );
644       return true;
645    }
646                 
647 return false;
648 } /* end getLineAndFile() */
649     
650 void BPatch_thread::setDynThread(dyn_thread *thr)
651 {
652   llthread = thr;
653   updated = false;
654 }
655
656 bool BPatch_thread::isVisiblyStopped()
657 {
658    return proc->isVisiblyStopped;
659 }
660
661 void BPatch_thread::markVisiblyStopped(bool new_state)
662 {
663    proc->isVisiblyStopped = new_state;
664 }