Possible fix for the debian/ubuntu bug of doom
[dyninst.git] / proccontrol / src / linux.C
1 /*
2  * See the dyninst/COPYRIGHT file for copyright information.
3  * 
4  * We provide the Paradyn Tools (below described as "Paradyn")
5  * on an AS IS basis, and do not warrant its validity or performance.
6  * We reserve the right to update, modify, or discontinue this
7  * software at any time.  We shall have no obligation to supply such
8  * updates or modifications or any other form of support to you.
9  * 
10  * By your use of Paradyn, you understand and agree that we (or any
11  * other person or entity with proprietary rights in Paradyn) are
12  * under no obligation to provide either maintenance services,
13  * update services, notices of latent defects, or correction of
14  * defects for Paradyn.
15  * 
16  * This library is free software; you can redistribute it and/or
17  * modify it under the terms of the GNU Lesser General Public
18  * License as published by the Free Software Foundation; either
19  * version 2.1 of the License, or (at your option) any later version.
20  * 
21  * This library is distributed in the hope that it will be useful,
22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
24  * Lesser General Public License for more details.
25  * 
26  * You should have received a copy of the GNU Lesser General Public
27  * License along with this library; if not, write to the Free Software
28  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
29  */
30
31 #include <sys/types.h>
32 #include <sys/wait.h>
33 #include <sys/syscall.h>
34 #include <sys/stat.h>
35 #include <sys/mman.h>
36 #include <fcntl.h>
37 #include <unistd.h>
38 #include <errno.h>
39 #include <string.h>
40 #include <assert.h>
41 #include <time.h>
42 #include <iostream>
43
44 #include "common/h/dyn_regs.h"
45 #include "common/h/dyntypes.h"
46
47 #include "common/src/pathName.h"
48 #include "proccontrol/h/PCErrors.h"
49 #include "proccontrol/h/Generator.h"
50 #include "proccontrol/h/Event.h"
51 #include "proccontrol/h/Handler.h"
52 #include "proccontrol/h/Mailbox.h"
53 #include "proccontrol/h/PlatFeatures.h"
54
55 #include "proccontrol/src/procpool.h"
56 #include "proccontrol/src/irpc.h"
57 #include "proccontrol/src/int_thread_db.h"
58 #include "proccontrol/src/linux.h"
59 #include "proccontrol/src/int_handler.h"
60 #include "proccontrol/src/response.h"
61 #include "proccontrol/src/int_event.h"
62
63 #include "proccontrol/src/snippets.h"
64
65 #include "common/src/linuxKludges.h"
66 #include "common/src/parseauxv.h"
67
68 // Before glibc-2.7, sys/ptrace.h lacked PTRACE_O_* and PTRACE_EVENT_*, so we
69 // need them from linux/ptrace.h.  (Conditionally, as later glibc conflicts.)
70 #if !__GLIBC_PREREQ(2,7)
71 #include <linux/ptrace.h>
72 #endif
73
74 using namespace Dyninst;
75 using namespace ProcControlAPI;
76
77 #if defined(WITH_SYMLITE)
78 #include "symlite/h/SymLite-elf.h"
79 #elif defined(WITH_SYMTAB_API)
80 #include "symtabAPI/h/SymtabReader.h"
81 #else
82 #error "No defined symbol reader"
83 #endif
84
85 #if !defined(PTRACE_GETREGS) && defined(PPC_PTRACE_GETREGS)
86 #define PTRACE_GETREGS PPC_PTRACE_GETREGS
87 #endif
88
89 #if !defined(PTRACE_SETREGS) && defined(PPC_PTRACE_SETREGS)
90 #define PTRACE_SETREGS PPC_PTRACE_SETREGS
91 #endif
92
93 static pid_t P_gettid();
94 static bool t_kill(int pid, int sig);
95
96 using namespace Dyninst;
97 using namespace std;
98
99 static GeneratorLinux *gen = NULL;
100
101 Generator *Generator::getDefaultGenerator()
102 {
103    if (!gen) {
104       gen = new GeneratorLinux();
105       assert(gen);
106       gen->launch();
107    }
108    return static_cast<Generator *>(gen);
109 }
110
111 bool GeneratorLinux::initialize()
112 {
113    int result;
114    
115    sigset_t usr2_set;
116    sigemptyset(&usr2_set);
117    sigaddset(&usr2_set, SIGUSR2);
118    result = pthread_sigmask(SIG_UNBLOCK, &usr2_set, NULL);
119    if (result != 0) {
120       perr_printf("Unable to unblock SIGUSR2: %s\n", strerror(result));
121    }
122    
123    generator_lwp = P_gettid();
124    generator_pid = P_getpid();
125    return true;
126 }
127
128 bool GeneratorLinux::canFastHandle()
129 {
130    return false;
131 }
132
133 ArchEvent *GeneratorLinux::getEvent(bool block)
134 {
135    int status, options;
136
137    //Block (or not block) in waitpid to receive a OS event
138    options = __WALL;
139    options |= block ? 0 : WNOHANG; 
140    pthrd_printf("%s in waitpid\n", block ? "blocking" : "polling");
141
142    if (isExitingState())
143       return NULL;
144    int pid = waitpid(-1, &status, options);
145
146    ArchEventLinux *newevent = NULL;
147    if (pid == -1) {
148       int errsv = errno;
149       if (errsv == EINTR) {
150          pthrd_printf("waitpid interrupted\n");
151          newevent = new ArchEventLinux(true);
152          return newevent;
153       }
154       perr_printf("Error. waitpid recieved error %s\n", strerror(errsv));
155       newevent = new ArchEventLinux(errsv);
156       return newevent;
157    }
158
159    if (dyninst_debug_proccontrol)
160    {
161       pthrd_printf("Waitpid return status %d for pid %d:\n", status, pid);
162       if (WIFEXITED(status))
163          pthrd_printf("Exited with %d\n", WEXITSTATUS(status));
164       else if (WIFSIGNALED(status))
165          pthrd_printf("Exited with signal %d\n", WTERMSIG(status));
166       else if (WIFSTOPPED(status))
167          pthrd_printf("Stopped with signal %d\n", WSTOPSIG(status));
168 #if defined(WIFCONTINUED)
169       else if (WIFCONTINUED(status))
170          perr_printf("Continued with signal SIGCONT (Unexpected)\n");
171 #endif
172       else 
173          pthrd_printf("Unable to interpret waitpid return.\n");
174    }
175    
176    newevent = new ArchEventLinux(pid, status);
177    return newevent;
178 }
179
180 GeneratorLinux::GeneratorLinux() :
181    GeneratorMT(std::string("Linux Generator")),
182    generator_lwp(0),
183    generator_pid(0)
184 {
185    decoders.insert(new DecoderLinux());
186 }
187
188 static volatile int on_sigusr2_hit;
189 static void on_sigusr2(int)
190 {
191    on_sigusr2_hit = 1;
192 }
193
194 void GeneratorLinux::evictFromWaitpid()
195 {
196    if (!generator_lwp)
197       return;
198    if (generator_pid != P_getpid())
199       return;
200    
201    //Throw a SIGUSR2 at the generator thread.  This will kick it out of
202    // a waitpid with EINTR, and allow it to exit.  Will do nothing if not
203    // blocked in waitpid.
204    //
205    //There's a subtle race condition here, which we can't easily fix.  
206    // The generator thread could be just before waitpid, but after 
207    // it's exit test when the signal hits.  We won't throw EINTR because
208    // we're not in waitpid yet, and we won't retest the exiting state.
209    // This exact kind of race is why we have things like pselect, but
210    // waitpid doesn't have a pwaitpid, so we're stuck.
211    struct sigaction newact, oldact;
212    memset(&newact, 0, sizeof(struct sigaction));
213    memset(&oldact, 0, sizeof(struct sigaction));
214    newact.sa_handler = on_sigusr2;
215
216    int result = sigaction(SIGUSR2, &newact, &oldact);
217    if (result == -1) {
218       int error = errno;
219       perr_printf("Error signaling generator thread: %s\n", strerror(error));
220       return;
221    }
222    on_sigusr2_hit = 0;
223    bool bresult = t_kill(generator_lwp, SIGUSR2);
224    while (bresult && !on_sigusr2_hit) {
225       //Don't use a lock because pthread_mutex_unlock is not signal safe
226       sched_yield();
227    }
228
229    result = sigaction(SIGUSR2, &oldact, NULL);
230    if (result == -1) {
231       int error = errno;
232       perr_printf("Error signaling generator thread: %s\n", strerror(error));
233    }
234 }
235
236
237 GeneratorLinux::~GeneratorLinux()
238 {
239    setState(exiting);
240    evictFromWaitpid();
241 }
242
243 DecoderLinux::DecoderLinux()
244 {
245 }
246
247 DecoderLinux::~DecoderLinux()
248 {
249 }
250
251 unsigned DecoderLinux::getPriority() const 
252 {
253    return Decoder::default_priority;
254 }
255
256 Dyninst::Address DecoderLinux::adjustTrapAddr(Dyninst::Address addr, Dyninst::Architecture arch)
257 {
258   if (arch == Dyninst::Arch_x86 || arch == Dyninst::Arch_x86_64) {
259     return addr-1;
260   }
261   return addr;
262 }
263
264 bool DecoderLinux::decode(ArchEvent *ae, std::vector<Event::ptr> &events)
265 {
266    bool result;
267    ArchEventLinux *archevent = static_cast<ArchEventLinux *>(ae);
268
269    int_process *proc = NULL;
270    linux_process *lproc = NULL;
271    int_thread *thread = ProcPool()->findThread(archevent->pid);
272    linux_thread *lthread = NULL;
273    if (thread) {
274       proc = thread->llproc();
275       lthread = dynamic_cast<linux_thread *>(thread);
276    }
277    if (proc) {
278       lproc = dynamic_cast<linux_process *>(proc);
279    }
280
281    if (ProcPool()->deadThread(archevent->pid)) {
282       return true;
283    }
284
285    if (!proc) {
286       pthrd_printf("Warning: could not find event for process %d\n", archevent->pid);
287    }
288
289    Event::ptr event = Event::ptr();
290    ArchEventLinux *child = NULL;
291    ArchEventLinux *parent = NULL;
292
293    pthrd_printf("Decoding event for %d/%d\n", proc ? proc->getPid() : -1,
294                 thread ? thread->getLWP() : -1);
295
296    const int status = archevent->status;
297    if (WIFSTOPPED(status))
298    {
299       const int stopsig = WSTOPSIG(status);
300       int ext;
301       pthrd_printf("Decoded to signal %d\n", stopsig);
302       switch (stopsig)
303       {
304          case (SIGTRAP | 0x80): //PTRACE_O_TRACESYSGOOD
305             if (!proc || !thread) {
306                 //Legacy event on old process?
307                 return true;
308             }
309             pthrd_printf("Decoded event to syscall-stop on %d/%d\n",
310                   proc->getPid(), thread->getLWP());
311             if (lthread->hasPostponedSyscallEvent()) {
312                delete archevent;
313                archevent = lthread->getPostponedSyscallEvent();
314                ext = archevent->event_ext;
315                switch (ext) {
316                   case PTRACE_EVENT_FORK:
317                   case PTRACE_EVENT_CLONE:
318                      pthrd_printf("Resuming %s event after syscall exit on %d/%d\n",
319                                   ext == PTRACE_EVENT_FORK ? "fork" : "clone",
320                                   proc->getPid(), thread->getLWP());
321                      if (!archevent->findPairedEvent(parent, child)) {
322                         pthrd_printf("Parent half of paired event, postponing decode "
323                                      "until child arrives\n");
324                         archevent->postponePairedEvent();
325                         return true;
326                      }
327                      break;
328                   case PTRACE_EVENT_EXEC:
329                      pthrd_printf("Resuming exec event after syscall exit on %d/%d\n",
330                                   proc->getPid(), thread->getLWP());
331                      event = Event::ptr(new EventExec(EventType::Post));
332                      event->setSyncType(Event::sync_process);
333                      break;
334                }
335                break;
336             }
337             // If we're expecting syscall events other than postponed ones, fall through the rest of
338             // the event handling
339             if(!thread->syscallMode())
340             {
341               perr_printf("Received an unexpected syscall TRAP\n");
342               return false;
343             }
344             
345          case SIGSTOP:
346             if (!proc) {               
347                //The child half of an event pair.  Find the parent or postpone it.
348                if (!archevent->findPairedEvent(parent, child)) {
349                   pthrd_printf("Child half of paired event, postponing decode " 
350                                "until parent arrives\n");
351                   archevent->postponePairedEvent();
352                   return true;
353                }
354                break;
355             }
356             if (lthread->hasPendingStop()) {
357                pthrd_printf("Recieved pending SIGSTOP on %d/%d\n", 
358                             thread->llproc()->getPid(), thread->getLWP());
359                event = Event::ptr(new EventStop());
360                break;
361             }
362             if (lthread->getGeneratorState().getState() == int_thread::neonatal ||
363                 lthread->getGeneratorState().getState() == int_thread::neonatal_intermediate)
364             {
365                //Discovered thread from refresh
366                pthrd_printf("Decoded event to thread bootstrap on %d/%d\n",
367                             proc->getPid(), thread->getLWP());
368                event = Event::ptr(new EventBootstrap());
369                break;
370             }
371          case SIGTRAP: {
372 #if 0
373             {
374                //Debugging code
375                Dyninst::MachRegisterVal addr;
376                result = thread->plat_getRegister(MachRegister::getPC(proc->getTargetArch()), addr);
377                if (!result) {
378                   fprintf(stderr, "Failed to read PC address upon crash\n");
379                }
380                fprintf(stderr, "Got SIGTRAP at %lx\n", addr);               
381             }
382 #endif
383             ext = status >> 16;
384             if (ext) {
385                bool postpone = false;
386                switch (ext) {
387                   case PTRACE_EVENT_EXIT:
388                      if (!proc || !thread) {
389                         //Legacy event on old process. 
390                         return true;
391                      }
392                      pthrd_printf("Decoded event to pre-exit on %d/%d\n",
393                                   proc->getPid(), thread->getLWP());
394                      if (thread->getLWP() == proc->getPid())
395                      {
396                        unsigned long exitcode = 0x0;
397                        int result = do_ptrace((pt_req)PTRACE_GETEVENTMSG, (pid_t) thread->getLWP(),
398                                               NULL, &exitcode);
399                        if(result == -1) 
400                        {
401                          perr_printf("Error getting event message from exit\n");
402                          return false;
403                        }
404                        exitcode = WEXITSTATUS(exitcode);
405                        
406                        pthrd_printf("Decoded event to pre-exit of process %d/%d with code %d\n",
407                                       proc->getPid(), thread->getLWP(), exitcode);
408                        event = Event::ptr(new EventExit(EventType::Pre, exitcode));
409                      } 
410                      else {
411                         EventLWPDestroy::ptr lwp_ev = EventLWPDestroy::ptr(new EventLWPDestroy(EventType::Pre));
412                         event = lwp_ev;
413                         event->setThread(thread->thread());
414                         lproc->decodeTdbLWPExit(lwp_ev);
415                      }
416                      thread->setExitingInGenerator(true);
417                      break;
418                   case PTRACE_EVENT_FORK: 
419                   case PTRACE_EVENT_CLONE: {
420                      if (!proc || !thread) {
421                         //Legacy event on old process. 
422                         return true;
423                      }
424                      pthrd_printf("Decoded event to %s on %d/%d\n",
425                                   ext == PTRACE_EVENT_FORK ? "fork" : "clone",
426                                   proc->getPid(), thread->getLWP());
427                      unsigned long cpid_l = 0x0;
428                      int result = do_ptrace((pt_req) PTRACE_GETEVENTMSG, (pid_t) thread->getLWP(), 
429                                             NULL, &cpid_l);
430                      if (result == -1) {
431                         perr_printf("Error getting event message from fork/clone\n");
432                         return false;
433                      }
434                      pid_t cpid = (pid_t) cpid_l;                     
435                      archevent->child_pid = cpid;
436                      postpone = true;
437                      break;
438                   }
439                   case PTRACE_EVENT_EXEC: {
440                      if (!proc || !thread) {
441                         //Legacy event on old process. 
442                         return true;
443                      }
444                      pthrd_printf("Decoded event to exec on %d/%d\n",
445                                   proc->getPid(), thread->getLWP());
446                      postpone = true;
447                      break;
448                   }
449                }
450                if (postpone) {
451                   pthrd_printf("Postponing event until syscall exit on %d/%d\n",
452                                proc->getPid(), thread->getLWP());
453                   archevent->event_ext = ext;
454                   event = Event::ptr(new EventPostponedSyscall());
455                   lthread->postponeSyscallEvent(archevent);
456                   archevent = NULL;
457                }
458                break;
459             }
460             if (proc->getState() == int_process::neonatal_intermediate) {
461                pthrd_printf("Decoded event to bootstrap on %d/%d\n",
462                             proc->getPid(), thread->getLWP());
463                event = Event::ptr(new EventBootstrap());
464                break;
465             }
466             Dyninst::MachRegisterVal addr;
467             Dyninst::Address adjusted_addr;
468             result = thread->plat_getRegister(MachRegister::getPC(proc->getTargetArch()), addr);
469             if (!result) {
470                perr_printf("Failed to read PC address upon SIGTRAP\n");
471                return false;
472             }
473             adjusted_addr = adjustTrapAddr(addr, proc->getTargetArch());
474
475             if (rpcMgr()->isRPCTrap(thread, adjusted_addr)) {
476                pthrd_printf("Decoded event to rpc completion on %d/%d at %lx\n",
477                             proc->getPid(), thread->getLWP(), adjusted_addr);
478                event = Event::ptr(new EventRPC(thread->runningRPC()->getWrapperForDecode()));
479                break;
480             }
481             bp_instance *clearingbp = thread->isClearingBreakpoint();
482             if (thread->singleStep() && clearingbp) {
483                 pthrd_printf("Decoded event to breakpoint restore\n");
484                 event = Event::ptr(new EventBreakpointRestore(new int_eventBreakpointRestore(clearingbp)));
485                 if (thread->singleStepUserMode()) {
486                    Event::ptr subservient_ss = EventSingleStep::ptr(new EventSingleStep());
487                    subservient_ss->setProcess(proc->proc());
488                    subservient_ss->setThread(thread->thread());
489                    subservient_ss->setSyncType(Event::sync_thread);
490                    event->addSubservientEvent(subservient_ss);
491                 }
492                 break;
493             }
494
495             // Need to distinguish case where the thread is single-stepped to a
496             // breakpoint and when a single step hits a breakpoint.
497             //
498             // If no forward progress was made due to a single step, then a
499             // breakpoint was hit
500             sw_breakpoint *ibp = proc->getBreakpoint(adjusted_addr);
501             if (thread->singleStep() && !ibp) {
502                pthrd_printf("Decoded event to single step on %d/%d\n",
503                        proc->getPid(), thread->getLWP());
504                event = Event::ptr(new EventSingleStep());
505                break;
506             }
507
508             if (thread->syscallMode() && !ibp) {
509                 if (thread->preSyscall()) {
510                     pthrd_printf("Decoded event to pre-syscall on %d/%d\n",
511                             proc->getPid(), thread->getLWP());
512                     event = Event::ptr(new EventPreSyscall());
513                     break; 
514                 } else {
515                     pthrd_printf("Decoded event to post-syscall on %d/%d\n",
516                             proc->getPid(), thread->getLWP());
517                     event = Event::ptr(new EventPostSyscall());
518                     break;
519                 }
520             }
521             
522             if (ibp && ibp != clearingbp) {
523                pthrd_printf("Decoded breakpoint on %d/%d at %lx\n", proc->getPid(), 
524                             thread->getLWP(), adjusted_addr);
525                EventBreakpoint::ptr event_bp = EventBreakpoint::ptr(new EventBreakpoint(new int_eventBreakpoint(adjusted_addr, ibp, thread)));
526                event = event_bp;
527                event->setThread(thread->thread());
528
529                if (thread->singleStepUserMode() && !proc->plat_breakpointAdvancesPC()) {
530                   Event::ptr subservient_ss = EventSingleStep::ptr(new EventSingleStep());
531                   subservient_ss->setProcess(proc->proc());
532                   subservient_ss->setThread(thread->thread());
533                   subservient_ss->setSyncType(Event::sync_thread);
534                   event->addSubservientEvent(subservient_ss);
535                }
536
537                if (adjusted_addr == lproc->getLibBreakpointAddr()) {
538                   pthrd_printf("Breakpoint is library load/unload\n");
539                   EventLibrary::ptr lib_event = EventLibrary::ptr(new EventLibrary());
540                   lib_event->setThread(thread->thread());
541                   lib_event->setProcess(proc->proc());
542                   lib_event->setSyncType(Event::sync_thread);
543                   event->addSubservientEvent(lib_event);
544                   break;
545                }
546                for (;;) {
547                   async_ret_t result = lproc->decodeTdbBreakpoint(event_bp);
548                   if (result == aret_error) {
549                      //Not really an error, just how we say that it isn't
550                      // a breakpoint.
551                      break;
552                   }
553                   if (result == aret_success) {
554                      //decodeTdbBreakpoint added a subservient event if this hits
555                      pthrd_printf("Breakpoint was thread event\n");
556                      break;
557                   }
558                   if (result == aret_async) {
559                      pthrd_printf("decodeTdbBreakpoint returned async\n");
560                      set<response::ptr> resps;
561                      lproc->getMemCache()->getPendingAsyncs(resps);
562                      pthrd_printf("%d asyncs are pending\n", (int) resps.size());
563                      int_process::waitForAsyncEvent(resps);
564                      continue;
565                   }
566                }
567
568                break;
569             }
570             response::ptr resp;
571             EventBreakpoint::ptr evhwbp = thread->decodeHWBreakpoint(resp);
572             if (evhwbp) {
573                pthrd_printf("Decoded SIGTRAP as hardware breakpoint\n");
574                event = evhwbp;
575                break;
576             }
577
578          }
579          default:
580             pthrd_printf("Decoded event to signal %d on %d/%d\n",
581                          stopsig, proc->getPid(), thread->getLWP());
582 #if 0
583             //Debugging code
584             if (stopsig == 11 || stopsig == 4) {
585                Dyninst::MachRegisterVal addr;
586                result = thread->plat_getRegister(MachRegister::getPC(proc->getTargetArch()), addr);
587                if (!result) {
588                   fprintf(stderr, "Failed to read PC address upon crash\n");
589                }
590                fprintf(stderr, "Got crash at %lx\n", addr);               
591                while (1) sleep(1);
592             }
593 #endif
594             event = Event::ptr(new EventSignal(stopsig));
595       }
596       if (event && event->getSyncType() == Event::unset)
597          event->setSyncType(Event::sync_thread);
598    }
599    else if ((WIFEXITED(status) || WIFSIGNALED(status)) && 
600             (!proc || !thread || thread->getGeneratorState().getState() == int_thread::exited)) 
601    {
602       //This can happen if the debugger process spawned the 
603       // child, but then detached.  We recieve the child process
604       // exit (because we're the parent), but are no longer debugging it.
605       // We'll just drop this event on the ground.
606       //Also seen when multiple termination signals hit a multi-threaded process
607       // we're debugging.  We'll keep pulling termination signals from the
608       // a defunct process.  Similar to above, we'll drop this event
609       // on the ground.
610       return true;
611    }
612    else if (WIFEXITED(status) && proc->getPid() != thread->getLWP())
613    {
614       int exitcode = WEXITSTATUS(status);
615
616       pthrd_printf("Decoded exit of thread %d/%d with code %d\n",
617                    proc->getPid(), thread->getLWP(), exitcode);
618       EventLWPDestroy::ptr lwp_ev = EventLWPDestroy::ptr(new EventLWPDestroy(EventType::Post));
619       event = lwp_ev;
620       event->setSyncType(Event::async);
621       event->setThread(thread->thread());
622       lproc->decodeTdbLWPExit(lwp_ev);
623       thread->getGeneratorState().setState(int_thread::exited);
624    }
625    else if (WIFEXITED(status) || WIFSIGNALED(status)) {
626       if (WIFEXITED(status)) {
627          int exitcode = WEXITSTATUS(status);
628          pthrd_printf("Decoded event to exit of process %d/%d with code %d\n",
629                       proc->getPid(), thread->getLWP(), exitcode);
630          event = Event::ptr(new EventExit(EventType::Post, exitcode));
631       }
632       else {
633          int termsig = WTERMSIG(status);
634          if( proc->wasForcedTerminated() ) {
635              pthrd_printf("Decoded event to force terminate of %d/%d\n",
636                      proc->getPid(), thread->getLWP());
637              event = Event::ptr(new EventForceTerminate(termsig));
638          }else{
639              pthrd_printf("Decoded event to crash of %d/%d with signal %d\n",
640                           proc->getPid(), thread->getLWP(), termsig);
641              event = Event::ptr(new EventCrash(termsig));
642          }
643       }
644       event->setSyncType(Event::sync_process);
645       int_threadPool::iterator i = proc->threadPool()->begin();
646       for (; i != proc->threadPool()->end(); i++) {
647          (*i)->getGeneratorState().setState(int_thread::exited);
648       }
649    }
650
651    if (parent && child)
652    {
653       //Paired event decoded
654       assert(!event);
655       thread = ProcPool()->findThread(parent->pid);
656       assert(thread);
657       proc = thread->llproc();
658       if (parent->event_ext == PTRACE_EVENT_FORK)
659          event = Event::ptr(new EventFork(EventType::Post, child->pid));
660       else if (parent->event_ext == PTRACE_EVENT_CLONE)
661          event = Event::ptr(new EventNewLWP(child->pid, (int) int_thread::as_created_attached));
662       else 
663          assert(0);
664       event->setSyncType(Event::sync_thread);
665       delete parent;
666       delete child;
667    }
668    else {
669       //Single event decoded
670       assert(event);
671       assert(!parent);
672       assert(!child);
673       assert(proc->proc());
674       assert(thread->thread());
675       delete archevent;
676    }
677    event->setThread(thread->thread());
678    event->setProcess(proc->proc());
679    events.push_back(event);
680
681    return true;
682 }
683
684 #if defined(arch_power)
685 #define DEFAULT_PROCESS_TYPE linux_ppc_process
686 #define DEFAULT_THREAD_TYPE linux_ppc_thread
687 #elif defined(arch_x86) || defined(arch_x86_64)
688 #define DEFAULT_PROCESS_TYPE linux_x86_process
689 #define DEFAULT_THREAD_TYPE linux_x86_thread
690 #endif
691
692 int_process *int_process::createProcess(Dyninst::PID p, std::string e)
693 {
694    std::vector<std::string> a;
695    std::map<int,int> f;
696    std::vector<std::string> envp;
697    LinuxPtrace::getPtracer(); //Make sure ptracer thread is initialized
698    linux_process *newproc = new DEFAULT_PROCESS_TYPE(p, e, a, envp, f);
699    assert(newproc);
700    return static_cast<int_process *>(newproc);
701 }
702
703 int_process *int_process::createProcess(std::string e, std::vector<std::string> a, std::vector<std::string> envp, 
704         std::map<int,int> f)
705 {
706    LinuxPtrace::getPtracer(); //Make sure ptracer thread is initialized
707    linux_process *newproc = new DEFAULT_PROCESS_TYPE(0, e, a, envp, f);
708    assert(newproc);
709    return static_cast<int_process *>(newproc);
710 }
711
712 int_process *int_process::createProcess(Dyninst::PID pid_, int_process *p)
713 {
714    linux_process *newproc = new DEFAULT_PROCESS_TYPE(pid_, p);
715    assert(newproc);
716    return static_cast<int_process *>(newproc);
717 }
718
719 int linux_process::computeAddrWidth(Dyninst::Architecture me)
720 {
721    /**
722     * It's surprisingly difficult to figure out the word size of a process
723     * without looking at the files it loads (we want to avoid disk accesses).
724     *
725     * /proc/PID/auxv offers a hackish opportunity to do this.  auxv contains
726     * a list of name value pairs.  On 64 bit processes these name values are
727     * a uint64/uint64 combo and on 32 bit processes they're uint32/uint32.
728     *
729     * The names are from a set of small integers (ranging from 0 to 37 at
730     * the time of this writing).  Since these are small numbers, the top half
731     * of name word will be 0x0 on 64 bit processes.  On 32-bit process this
732     * word will contain a value, of which some should be non-zero.  
733     *
734     * We'll thus check every word that is 1 mod 4.  If all are 0x0 we assume we're
735     * looking at a 64-bit process.
736     **/
737    uint32_t buffer[256];
738    char auxv_name[64];
739    
740    snprintf(auxv_name, 64, "/proc/%d/auxv", getPid());
741    int fd = open(auxv_name, O_RDONLY);
742    if (fd == -1) { 
743       pthrd_printf("Couldn't open %s to determine address width: %s",
744                    auxv_name, strerror(errno));
745       return -1;
746    }
747
748    long int result = read(fd, buffer, sizeof(buffer));
749    long int words_read = result / sizeof(uint32_t);
750    int word_size = 8;
751
752    // We want to check the highest 4 bytes of each integer
753    // On big-endian systems, these come first in memory
754    int start_index = 0;
755    switch (me) {
756       case Arch_x86:
757       case Arch_x86_64:
758          start_index = 1;
759          break;
760       case Arch_ppc32:
761       case Arch_ppc64:
762          start_index = 0;
763          break;
764       case Arch_none:
765       default:
766          assert(0);
767          return 0;
768    }
769
770    for (long int i=start_index; i<words_read; i+= 4)
771    {
772       if (buffer[i] != 0) {
773          word_size = 4;
774          break;
775       }
776    }
777    close(fd);
778    return word_size;
779 }
780
781 linux_process::linux_process(Dyninst::PID p, std::string e, std::vector<std::string> a, 
782                              std::vector<std::string> envp,  std::map<int,int> f) :
783    int_process(p, e, a, envp, f),
784    resp_process(p, e, a, envp, f),
785    sysv_process(p, e, a, envp, f),
786    unix_process(p, e, a, envp, f),
787    thread_db_process(p, e, a, envp, f),
788    indep_lwp_control_process(p, e, a, envp, f),
789    mmap_alloc_process(p, e, a, envp, f),
790    int_followFork(p, e, a, envp, f),
791    int_signalMask(p, e, a, envp, f),
792    int_LWPTracking(p, e, a, envp, f),
793    int_memUsage(p, e, a, envp, f)
794 {
795 }
796
797 linux_process::linux_process(Dyninst::PID pid_, int_process *p) :
798    int_process(pid_, p),
799    resp_process(pid_, p),
800    sysv_process(pid_, p),
801    unix_process(pid_, p),
802    thread_db_process(pid_, p),
803    indep_lwp_control_process(pid_, p),
804    mmap_alloc_process(pid_, p),
805    int_followFork(pid_, p),
806    int_signalMask(pid_, p),
807    int_LWPTracking(pid_, p),
808    int_memUsage(pid_, p)
809 {
810 }
811
812 linux_process::~linux_process()
813 {
814 }
815
816 bool linux_process::plat_create()
817 {
818    //Triggers plat_create_int on ptracer thread.
819    return LinuxPtrace::getPtracer()->plat_create(this);
820 }
821
822 bool linux_process::plat_create_int()
823 {
824    pid = fork();
825    if (pid == -1)
826    {
827       int errnum = errno;
828       pthrd_printf("Could not fork new process for %s: %s\n", 
829                    executable.c_str(), strerror(errnum));
830       setLastError(err_internal, "Unable to fork new process");
831       return false;
832    }
833
834    if (!pid)
835    {
836       // Make sure cleanup on failure goes smoothly
837       ProcPool()->condvar()->unlock();
838
839       //Child
840       long int result = ptrace((pt_req) PTRACE_TRACEME, 0, 0, 0);
841       if (result == -1)
842       {
843          pthrd_printf("Failed to execute a PTRACE_TRACME.  Odd.\n");
844          setLastError(err_internal, "Unable to debug trace new process");
845          exit(-1);
846       }
847
848       // Never returns
849       plat_execv();
850    }
851    return true;
852 }
853
854 bool linux_process::plat_getOSRunningStates(std::map<Dyninst::LWP, bool> &runningStates) {
855     vector<Dyninst::LWP> lwps;
856     if( !getThreadLWPs(lwps) ) {
857         pthrd_printf("Failed to determine lwps for process %d\n", getPid());
858         setLastError(err_noproc, "Failed to find /proc files for debuggee");
859         return false;
860     }
861
862     for(vector<Dyninst::LWP>::iterator i = lwps.begin();
863             i != lwps.end(); ++i)
864     {
865         char proc_stat_name[128];
866         char sstat[256];
867         char *status;
868         int paren_level = 1;
869         
870         snprintf(proc_stat_name, 128, "/proc/%d/stat", *i);
871         FILE *sfile = fopen(proc_stat_name, "r");
872
873         if (sfile == NULL) {
874             pthrd_printf("Failed to open /proc/%d/stat file\n", *i);
875             setLastError(err_noproc, "Failed to find /proc files for debuggee");
876             return false;
877         }
878         if( fread(sstat, 1, 256, sfile) == 0 ) {
879             pthrd_printf("Failed to read /proc/%d/stat file \n", *i);
880             setLastError(err_noproc, "Failed to find /proc files for debuggee");
881             fclose(sfile);
882             return false;
883         }
884         fclose(sfile);
885
886         sstat[255] = '\0';
887         status = sstat;
888
889         while (*status != '\0' && *(status++) != '(') ;
890         while (*status != '\0' && paren_level != 0) {
891             if (*status == '(') paren_level++;
892             if (*status == ')') paren_level--;
893             status++;
894         }
895
896         while (*status == ' ') status++;
897
898         runningStates.insert(make_pair(*i, (*status != 'T')));
899     }
900
901     return true;
902 }
903
904 // Ubuntu 10.10 and other hardened systems do not allow arbitrary ptrace_attaching; instead
905 // you may only attach to a child process (https://wiki.ubuntu.com/SecurityTeam/Roadmap/KernelHardening)
906 //
907 // We can detect this and warn the user; however, it takes root to disable it. 
908
909 #include <fstream>
910
911 static void warn_user_ptrace_restrictions() {
912   ifstream ptrace_scope("/proc/sys/kernel/yama/ptrace_scope");
913   if (ptrace_scope.is_open()) {
914     int val = 99;
915     ptrace_scope >> val;
916     if (val == 1) {
917       cerr << "Warning: your Linux system provides limited ptrace functionality as a security" << endl
918            << "measure. This measure prevents ProcControl and Dyninst from attaching to binaries." << endl
919            << "To temporarily disable this measure (until a reboot), execute the following command:" << endl
920            << "\techo 0 > /proc/sys/kernel/yama/ptrace_scope" << endl;
921       struct stat statbuf;
922       if (!stat("/etc/sysctl.d/10-ptrace.conf", &statbuf)) {
923         cerr << "To permanently disable this measure, edit the file \"/etc/sysctl.d/10-ptrace.conf\"" << endl
924              << "and follow the directions in that file." << endl;
925       }
926       cerr << "For more information, see https://wiki.ubuntu.com/SecurityTeam/Roadmap/KernelHardening" << endl;
927       is_restricted_ptrace = true;
928     }
929   } 
930 }
931
932
933 bool linux_process::plat_attach(bool, bool &)
934 {
935    pthrd_printf("Attaching to pid %d\n", pid);
936
937    bool attachWillTriggerStop = plat_attachWillTriggerStop();
938
939    int result = do_ptrace((pt_req) PTRACE_ATTACH, pid, NULL, NULL);
940    if (result != 0) {
941       int errnum = errno;
942       pthrd_printf("Unable to attach to process %d: %s\n", pid, strerror(errnum));
943       switch(errnum) {
944       case EPERM:
945         warn_user_ptrace_restrictions();
946         setLastError(err_prem, "Do not have correct premissions to attach to pid");
947         break;
948       case ESRCH:
949          setLastError(err_noproc, "The specified process was not found");
950          break;
951       default:
952          setLastError(err_internal, "Unable to attach to the specified process");
953          break;
954       }
955       return false;
956    }
957
958    if ( !attachWillTriggerStop ) {
959        // Force the SIGSTOP delivered by the attach to be handled
960        pthrd_printf("Attach will not trigger stop, calling PTRACE_CONT to flush out stop\n");
961        int result = do_ptrace((pt_req) PTRACE_CONT, pid, NULL, NULL);
962        if( result != 0 ) {
963            int errnum = errno;
964            pthrd_printf("Unable to continue process %d to flush out attach: %s\n",
965                    pid, strerror(errnum));
966            return false;
967        }
968    }
969    
970    return true;
971 }
972
973 bool linux_process::plat_attachWillTriggerStop() {
974     char procName[64];
975     char cmd[256];
976     pid_t tmpPid;
977     char state;
978     int ttyNumber;
979
980     // Retrieve the state of the process and its controlling tty
981     snprintf(procName, 64, "/proc/%d/stat", pid);
982
983     FILE *sfile = fopen(procName, "r");
984     if ( sfile == NULL ) {
985         perr_printf("Failed to determine whether attach would trigger stop -- assuming it will\n");
986         return true;
987     }
988
989     fscanf(sfile, "%d %255s %c %d %d %d",
990             &tmpPid, cmd, &state,
991             &tmpPid, &tmpPid, &ttyNumber);
992     fclose(sfile);
993
994     // If the process is stopped and it has a controlling tty, an attach
995     // will not trigger a stop
996     if ( state == 'T' && ttyNumber != 0 ) {
997         return false;
998     }
999
1000     return true;
1001 }
1002
1003 bool linux_process::plat_execed()
1004 {
1005    bool result = sysv_process::plat_execed();
1006    if (!result)
1007       return false;
1008
1009    char proc_exec_name[128];
1010    snprintf(proc_exec_name, 128, "/proc/%d/exe", getPid());
1011    executable = resolve_file_path(proc_exec_name);
1012    return true;
1013 }
1014
1015 bool linux_process::plat_forked()
1016 {
1017    return true;
1018 }
1019
1020 bool linux_process::plat_readMem(int_thread *thr, void *local, 
1021                                  Dyninst::Address remote, size_t size)
1022 {
1023    return LinuxPtrace::getPtracer()->ptrace_read(remote, size, local, thr->getLWP());
1024 }
1025
1026 bool linux_process::plat_writeMem(int_thread *thr, const void *local, 
1027                                   Dyninst::Address remote, size_t size, bp_write_t)
1028 {
1029    return LinuxPtrace::getPtracer()->ptrace_write(remote, size, local, thr->getLWP());
1030 }
1031
1032 linux_x86_process::linux_x86_process(Dyninst::PID p, std::string e, std::vector<std::string> a, 
1033                                      std::vector<std::string> envp, std::map<int,int> f) :
1034    int_process(p, e, a, envp, f),
1035    resp_process(p, e, a, envp, f),
1036    linux_process(p, e, a, envp, f),
1037    x86_process(p, e, a, envp, f)
1038 {
1039 }
1040
1041 linux_x86_process::linux_x86_process(Dyninst::PID pid_, int_process *p) :
1042    int_process(pid_, p),
1043    resp_process(pid_, p),
1044    linux_process(pid_, p),
1045    x86_process(pid_, p)
1046 {
1047 }
1048
1049
1050 linux_x86_process::~linux_x86_process()
1051 {
1052 }
1053
1054 Dyninst::Architecture linux_x86_process::getTargetArch()
1055 {
1056    if (arch != Dyninst::Arch_none) {
1057       return arch;
1058    }
1059    int addr_width = computeAddrWidth(sizeof(void *) == 4 ? Arch_x86 : Arch_x86_64);
1060    arch = (addr_width == 4) ? Dyninst::Arch_x86 : Dyninst::Arch_x86_64;
1061    return arch;
1062 }
1063
1064 bool linux_x86_process::plat_supportHWBreakpoint()
1065 {
1066    return true;
1067 }
1068
1069 linux_ppc_process::linux_ppc_process(Dyninst::PID p, std::string e, std::vector<std::string> a, 
1070                                      std::vector<std::string> envp, std::map<int,int> f) :
1071    int_process(p, e, a, envp, f),
1072    resp_process(p, e, a, envp, f),
1073    linux_process(p, e, a, envp, f),
1074    ppc_process(p, e, a, envp, f)
1075 {
1076 }
1077
1078 linux_ppc_process::linux_ppc_process(Dyninst::PID pid_, int_process *p) :
1079    int_process(pid_, p),
1080    resp_process(pid_, p),
1081    linux_process(pid_, p),
1082    ppc_process(pid_, p)
1083 {
1084 }
1085
1086
1087 linux_ppc_process::~linux_ppc_process()
1088 {
1089 }
1090
1091 Dyninst::Architecture linux_ppc_process::getTargetArch()
1092 {
1093    if (arch != Dyninst::Arch_none) {
1094       return arch;
1095    }
1096    int addr_width = computeAddrWidth(sizeof(void *) == 4 ? Arch_ppc32 : Arch_ppc64);
1097    arch = (addr_width == 4) ? Dyninst::Arch_ppc32 : Dyninst::Arch_ppc64;
1098    return arch;
1099 }
1100
1101 static std::vector<unsigned int> fake_async_msgs;
1102 void linux_thread::fake_async_main(void *)
1103 {
1104    for (;;) {
1105       //Sleep for a small amount of time.
1106       struct timespec sleep_time;
1107       sleep_time.tv_sec = 0;
1108       sleep_time.tv_nsec = 1000000; //One milisecond
1109       nanosleep(&sleep_time, NULL);
1110
1111       if (fake_async_msgs.empty())
1112          continue;
1113
1114       getResponses().lock();
1115       
1116       //Pick a random async response to fill.
1117       int size = fake_async_msgs.size();
1118       int elem = rand() % size;
1119       unsigned int id = fake_async_msgs[elem];
1120       fake_async_msgs[elem] = fake_async_msgs[size-1];
1121       fake_async_msgs.pop_back();
1122       
1123       pthrd_printf("Faking response for event %d\n", id);
1124       //Pull the response from the list
1125       response::ptr resp = getResponses().rmResponse(id);
1126       assert(resp != response::ptr());
1127       
1128       //Add data to the response.
1129       reg_response::ptr regr = resp->getRegResponse();
1130       allreg_response::ptr allr = resp->getAllRegResponse();
1131       result_response::ptr resr = resp->getResultResponse();
1132       mem_response::ptr memr = resp->getMemResponse();
1133       if (regr)
1134          regr->postResponse(regr->val);
1135       else if (allr)
1136          allr->postResponse();
1137       else if (resr)
1138          resr->postResponse(resr->b);
1139       else if (memr)
1140          memr->postResponse();
1141       else
1142          assert(0);
1143       
1144       Event::ptr ev = resp->getEvent();
1145       if (ev == Event::ptr()) {
1146          //Someone is blocking for this response, mark it ready
1147          pthrd_printf("Marking response %s ready\n", resp->name().c_str());
1148          resp->markReady();
1149       }
1150       else {
1151          //An event triggered this async, create a new Async event
1152          // with the original event as subservient.
1153          int_eventAsync *internal = new int_eventAsync(resp);
1154          EventAsync::ptr async_ev(new EventAsync(internal));
1155          async_ev->setProcess(ev->getProcess());
1156          async_ev->setThread(ev->getThread());
1157          async_ev->setSyncType(Event::async);
1158          async_ev->addSubservientEvent(ev);
1159          
1160          pthrd_printf("Enqueueing Async event with subservient %s to mailbox\n", ev->name().c_str());
1161          mbox()->enqueue(async_ev, true);
1162       }
1163       
1164       getResponses().signal();
1165       getResponses().unlock();
1166    }
1167 }
1168
1169 bool linux_process::plat_needsAsyncIO() const
1170 {
1171 #if !defined(debug_async_simulate)
1172    return false;
1173 #endif
1174    static DThread *fake_async_thread = NULL;
1175    if (!fake_async_thread) {
1176       fake_async_thread = new DThread();
1177       bool result = fake_async_thread->spawn(linux_thread::fake_async_main, NULL);
1178       assert(result);
1179       if(!result) return false;
1180    }
1181    return true;
1182 }
1183
1184 bool linux_process::plat_readMemAsync(int_thread *thr, Dyninst::Address addr, mem_response::ptr result)
1185 {
1186    bool b = plat_readMem(thr, result->getBuffer(), addr, result->getSize());
1187    if (!b) {
1188       result->markError(getLastError());      
1189    }
1190    result->setLastBase(addr);
1191    fake_async_msgs.push_back(result->getID());
1192    return true;
1193 }
1194
1195 bool linux_process::plat_writeMemAsync(int_thread *thr, const void *local, Dyninst::Address addr, size_t size, 
1196                                        result_response::ptr result, bp_write_t bp_write)
1197 {
1198    bool b = plat_writeMem(thr, local, addr, size, bp_write);
1199    if (!b) {
1200       result->markError(getLastError());
1201       result->b = false;
1202    }
1203    else {
1204       result->b = true;
1205    }
1206    fake_async_msgs.push_back(result->getID());
1207    return true;
1208 }
1209
1210 bool linux_process::needIndividualThreadAttach()
1211 {
1212    return true;
1213 }
1214
1215 bool linux_process::getThreadLWPs(std::vector<Dyninst::LWP> &lwps)
1216 {
1217    return findProcLWPs(pid, lwps);
1218 }
1219
1220 bool linux_process::plat_supportLWPCreate() 
1221 {
1222    return true;
1223 }
1224
1225 bool linux_process::plat_supportLWPPreDestroy()
1226 {
1227    return true;
1228 }
1229
1230 bool linux_process::plat_supportLWPPostDestroy()
1231 {
1232    return true;
1233 }
1234
1235 void linux_thread::postponeSyscallEvent(ArchEventLinux *event)
1236 {
1237    assert(!postponed_syscall_event);
1238    postponed_syscall_event = event;
1239 }
1240
1241 bool linux_thread::hasPostponedSyscallEvent()
1242 {
1243    return postponed_syscall_event != NULL;
1244 }
1245
1246 ArchEventLinux *linux_thread::getPostponedSyscallEvent()
1247 {
1248    ArchEventLinux *ret = postponed_syscall_event;
1249    postponed_syscall_event = NULL;
1250    return ret;
1251 }
1252
1253
1254 bool linux_thread::plat_cont()
1255 {
1256    pthrd_printf("Continuing thread %d\n", lwp);
1257
1258    switch (getHandlerState().getState()) {
1259       case neonatal:
1260       case running:
1261       case exited:
1262       case errorstate:
1263       case detached:
1264          perr_printf("Continue attempted on thread in invalid state %s\n", 
1265                      int_thread::stateStr(handler_state.getState()));
1266          return false;
1267       case neonatal_intermediate:
1268       case stopped:
1269          //OK
1270          break;
1271       case none:
1272       case dontcare:
1273       case ditto:
1274          assert(0);
1275    }
1276
1277    // The following case poses a problem:
1278    // 1) This thread has received a signal, but the event hasn't been handled yet
1279    // 2) An event that precedes the signal event triggers a callback where
1280    //    the user requests that the whole process stop. This in turn causes
1281    //    the thread to be sent a SIGSTOP because the Handler hasn't seen the
1282    //    signal event yet.
1283    // 3) Before handling the pending signal event, this thread is continued to
1284    //    clear out the pending stop and consequently, it is delivered the signal
1285    //    which can cause the whole process to crash
1286    //
1287    // The solution:
1288    // Don't continue the thread with the pending signal if there is a pending stop.
1289    // Wait until the user sees the signal event to deliver the signal to the process.
1290    //
1291    
1292    int tmpSignal = continueSig_;
1293    // The above isn't quite right. In the cases where the signal we're not handling is
1294    // a term/core signal, we want to ensure that we don't mistakenly forward the signal
1295    // before we handle (and potentially squash) it.
1296    // In the case where it's by default ignored (which is SIGCHLD only, on Linux),
1297    // we want to use the existing "please continue with this signal" to get us to the
1298    // pending stop.
1299    // In the case where it's a stopping signal other than SIGSTOP, I'm not sure what happens.
1300    if( hasPendingStop() && (tmpSignal != SIGCHLD)) {
1301        tmpSignal = 0;
1302    }
1303
1304    void *data = (tmpSignal == 0) ? NULL : (void *) (long) tmpSignal;
1305    int result;
1306    if (hasPostponedSyscallEvent())
1307    {
1308       pthrd_printf("Calling PTRACE_SYSCALL on %d with signal %d\n", lwp, tmpSignal);
1309       result = do_ptrace((pt_req) PTRACE_SYSCALL, lwp, NULL, data);
1310    }
1311    else if (singleStep())
1312    {
1313       pthrd_printf("Calling PTRACE_SINGLESTEP on %d with signal %d\n", lwp, tmpSignal);
1314       result = do_ptrace((pt_req) PTRACE_SINGLESTEP, lwp, NULL, data);
1315    }
1316    else if (syscallMode())
1317    {
1318         pthrd_printf("Calling PTRACE_SYSCALL on %d with signal %d\n", lwp, tmpSignal);
1319         result = do_ptrace((pt_req) PTRACE_SYSCALL, lwp, NULL, data);
1320    }
1321    else 
1322    {
1323       pthrd_printf("Calling PTRACE_CONT on %d with signal %d\n", lwp, tmpSignal);
1324       result = do_ptrace((pt_req) PTRACE_CONT, lwp, NULL, data);
1325    }
1326    if (result == -1) {
1327       int error = errno;
1328       if (error == ESRCH) {
1329          pthrd_printf("Continue attempted on exited thread %d\n", lwp);
1330          setLastError(err_exited, "Continue on exited thread");
1331          return false;
1332       }
1333       perr_printf("low-level continue failed: %s\n", strerror(error));
1334       setLastError(err_internal, "Low-level continue failed\n");
1335       return false;
1336    }
1337    if( tmpSignal == continueSig_ ) continueSig_ = 0;
1338
1339    return true;
1340 }
1341
1342 SymbolReaderFactory *getElfReader()
1343 {
1344 #if defined(WITH_SYMLITE)
1345   static SymbolReaderFactory *symreader_factory = NULL;
1346   if (symreader_factory)
1347     return symreader_factory;
1348
1349   symreader_factory = (SymbolReaderFactory *) new SymElfFactory();
1350   return symreader_factory;
1351 #elif defined(WITH_SYMTAB_API)
1352   return SymtabAPI::getSymtabReaderFactory();
1353 #else
1354 #error "No defined symbol reader"
1355 #endif
1356 }
1357
1358 SymbolReaderFactory *linux_process::plat_defaultSymReader()
1359 {
1360    return getElfReader();
1361 }
1362
1363
1364 #ifndef SYS_tkill
1365 #define SYS_tkill 238
1366 #endif
1367
1368 static pid_t P_gettid()
1369 {
1370   static int gettid_not_valid = 0;
1371   long int result;
1372
1373   if (gettid_not_valid)
1374     return getpid();
1375
1376   result = syscall(SYS_gettid);
1377   if (result == -1 && errno == ENOSYS)
1378   {
1379     gettid_not_valid = 1;
1380     return getpid();
1381   }
1382   return (int) result;
1383 }
1384
1385 static bool t_kill(int pid, int sig)
1386 {
1387   static bool has_tkill = true;
1388   long int result = 0;
1389   pthrd_printf("Sending %d to %d\n", sig, pid);
1390   if (has_tkill) {
1391      result = syscall(SYS_tkill, pid, sig);
1392      if (result == -1 && errno == ENOSYS)
1393      {
1394         pthrd_printf("Using kill instead of tkill on this system\n");
1395         has_tkill = false;
1396      }
1397   }
1398   if (!has_tkill) {
1399      result = kill(pid, sig);
1400   }
1401
1402   return (result == 0);
1403 }
1404
1405 int_thread *int_thread::createThreadPlat(int_process *proc, 
1406                                          Dyninst::THR_ID thr_id, 
1407                                          Dyninst::LWP lwp_id,
1408                                          bool initial_thrd)
1409 {
1410    if (initial_thrd) {
1411       lwp_id = proc->getPid();
1412    }
1413    linux_thread *lthrd = new DEFAULT_THREAD_TYPE(proc, thr_id, lwp_id);
1414    assert(lthrd);
1415    return static_cast<int_thread *>(lthrd);
1416 }
1417
1418 linux_thread::linux_thread(int_process *p, Dyninst::THR_ID t, Dyninst::LWP l) :
1419    int_thread(p, t, l),
1420    thread_db_thread(p, t, l),
1421    postponed_syscall_event(NULL)
1422 {
1423 }
1424
1425 linux_thread::~linux_thread()
1426 {
1427    delete postponed_syscall_event;
1428 }
1429
1430 bool linux_thread::plat_stop()
1431 {
1432    bool result;
1433
1434    assert(pending_stop.local());
1435    result = t_kill(lwp, SIGSTOP);
1436    if (!result) {
1437       int err = errno;
1438       if (err == ESRCH) {
1439          pthrd_printf("t_kill failed on %d, thread doesn't exist\n", lwp);
1440          setLastError(err_noproc, "Thread no longer exists");
1441          return false;
1442       }
1443       pthrd_printf("t_kill failed on %d: %s\n", lwp, strerror(err));
1444       setLastError(err_internal, "Could not send signal to process while stopping");
1445       return false;
1446    }
1447
1448    return true;
1449 }
1450
1451 void linux_thread::setOptions()
1452 {
1453    long options = 0;
1454    options |= PTRACE_O_TRACEEXIT;
1455    options |= PTRACE_O_TRACEEXEC;
1456    options |= PTRACE_O_TRACESYSGOOD;
1457    if (llproc()->getLWPTracking()->lwp_getTracking())
1458       options |= PTRACE_O_TRACECLONE;
1459    if (llproc()->getFollowFork()->fork_isTracking() != FollowFork::ImmediateDetach)
1460       options |= PTRACE_O_TRACEFORK;
1461
1462    if (options) {
1463       int result = do_ptrace((pt_req) PTRACE_SETOPTIONS, lwp, NULL, 
1464                           (void *) options);
1465       if (result == -1) {
1466          pthrd_printf("Failed to set options for %lu: %s\n", tid, strerror(errno));
1467       }
1468    }   
1469 }
1470
1471 bool linux_thread::unsetOptions()
1472 {
1473     long options = 0;
1474
1475     int result = do_ptrace((pt_req) PTRACE_SETOPTIONS, lwp, NULL,
1476             (void *) options);
1477     if (result == -1) {
1478         pthrd_printf("Failed to set options for %lu: %s\n", tid, strerror(errno));
1479         return false;
1480     }
1481     return true;
1482 }
1483
1484 bool linux_process::plat_individualRegAccess()
1485 {
1486    return true;
1487 }
1488
1489 bool linux_process::plat_detach(result_response::ptr, bool leave_stopped)
1490 {
1491    int_threadPool *tp = threadPool();
1492    bool had_error = false;
1493    bool first_thread_signaled = false;
1494
1495    for (int_threadPool::iterator i = tp->begin(); i != tp->end(); i++) {
1496       int_thread *thr = *i;
1497       if (leave_stopped && !first_thread_signaled) {
1498          pthrd_printf("Signaling %d/%d with SIGSTOP during detach to leave stopped\n", getPid(), thr->getLWP());
1499          t_kill(thr->getLWP(), SIGSTOP);
1500          first_thread_signaled = true;
1501       }
1502       pthrd_printf("PTRACE_DETACH on %d\n", thr->getLWP());
1503       long result = do_ptrace((pt_req) PTRACE_DETACH, thr->getLWP(), NULL, (void *) 0);
1504       if (result == -1) {
1505          had_error = true;
1506          perr_printf("Failed to PTRACE_DETACH on %d/%d (%s)\n", getPid(), thr->getLWP(), strerror(errno));
1507          setLastError(err_internal, "PTRACE_DETACH operation failed\n");
1508       }
1509    }
1510    // Before we return from detach, make sure that we've gotten out of waitpid()
1511    // so that we don't steal events on that process.
1512    GeneratorLinux* g = dynamic_cast<GeneratorLinux*>(Generator::getDefaultGenerator());
1513    assert(g);
1514    g->evictFromWaitpid();
1515    
1516    return !had_error;
1517 }
1518
1519 bool linux_process::plat_terminate(bool &needs_sync)
1520 {
1521    //ProcPool lock should be held.
1522    //I had been using PTRACE_KILL here, but that was proving to be inconsistent.
1523
1524
1525    pthrd_printf("Terminating process %d\n", getPid());
1526    int result = kill(getPid(), SIGKILL);
1527    if (result == -1) {
1528       if (errno == ESRCH) {
1529          perr_printf("Process %d no longer exists\n", getPid());
1530          setLastError(err_noproc, "Process no longer exists");
1531       }
1532       else {
1533          perr_printf("Failed to kill(%d, SIGKILL) process\n", getPid());
1534          setLastError(err_internal, "Unexpected failure of kill\n");
1535          return false;
1536       }
1537    }
1538
1539    needs_sync = true;
1540    return true;
1541 }
1542
1543 bool linux_process::preTerminate() {
1544
1545    pthrd_printf("Stopping process %d for pre-terminate handling\n", getPid());
1546    threadPool()->initialThread()->getInternalState().desyncStateProc(int_thread::stopped);
1547    bool threw_event = false;
1548    while (!threadPool()->allStopped(int_thread::InternalStateID)) {
1549       if (!threw_event) {
1550          throwNopEvent();
1551          threw_event = true;
1552       }
1553       bool exited = false;
1554       auto pid = getPid();
1555       int_process::waitAndHandleForProc(true, this, exited);
1556       if (exited) {
1557          // Note, can't even call getPid() anymore, since 'this' is ironically deleted.
1558          perr_printf("Process %d exited during terminate handling.  Is this irony?\n", pid);
1559          return false;
1560       }
1561    }
1562    pthrd_printf("Putting process %d back into previous state\n", getPid());
1563    threadPool()->initialThread()->getInternalState().restoreStateProc();
1564
1565 #if defined(bug_force_terminate_failure)
1566     // On some Linux versions (currently only identified on our power platform),
1567     // a force terminate can fail to actually kill a process due to some OS level
1568     // race condition. The result is that some threads in a process are stopped
1569     // instead of exited and for some reason, continues will not continue the 
1570     // process. This can be detected because some OS level structures (such as pipes)
1571     // still exist for the terminated process
1572
1573     // It appears that this bug largely results from the pre-LWP destroy and pre-Exit
1574     // events being delivered to the debugger, so we stop the process and disable these
1575     // events for all threads in the process
1576
1577    int_threadPool::iterator i;
1578    for(i = threadPool()->begin(); i != threadPool()->end(); i++)
1579    {
1580       linux_thread *thr = dynamic_cast<linux_thread *>(*i);
1581       pthrd_printf("Disabling syscall tracing events for thread %d/%d\n",
1582                    getPid(), thr->getLWP());
1583       if( !thr->unsetOptions() ) {
1584          perr_printf("Failed to unset options for thread %d/%d in pre-terminate handling\n",
1585                      getPid(), thr->getLWP());
1586          return false;
1587       }
1588    }
1589 #endif
1590    
1591    // We don't want to be mixing termination and breakpoint stepping. 
1592    removeAllBreakpoints();
1593
1594    // And put things back where we found them. 
1595    throwNopEvent();
1596
1597    pthrd_printf("Waiting for process %d to resynchronize before terminating\n", getPid());
1598    int_process::waitAndHandleEvents(false);
1599
1600    return true;
1601 }
1602
1603 OSType linux_process::getOS() const
1604 {
1605    return Dyninst::Linux;
1606 }
1607
1608 Dyninst::Address linux_process::plat_mallocExecMemory(Dyninst::Address min, unsigned size) {
1609     Dyninst::Address result = 0x0;
1610     bool found_result = false;
1611     unsigned maps_size;
1612     map_entries *maps = getVMMaps(getPid(), maps_size);
1613     assert(maps); //TODO, Perhaps go to libraries for address map if no /proc/
1614     for (unsigned i=0; i<maps_size; i++) {
1615         if (!(maps[i].prems & PREMS_EXEC))
1616             continue;
1617         if (min + size > maps[i].end)
1618             continue;
1619         if (maps[i].end - maps[i].start < size)
1620             continue;
1621
1622         if (maps[i].start > min)
1623             result = maps[i].start;
1624         else
1625             result = min;
1626         found_result = true;
1627         break;
1628     }
1629     assert(found_result);
1630     free(maps);
1631     return result;
1632 }
1633
1634 bool linux_process::fork_setTracking(FollowFork::follow_t f)
1635 {
1636    int_threadPool::iterator i;      
1637    for (i = threadPool()->begin(); i != threadPool()->end(); i++) {
1638       int_thread *thrd = *i;
1639       if (thrd->getUserState().getState() != int_thread::stopped) {
1640          perr_printf("Could not set fork tracking because thread %d/%d was not stopped\n", 
1641                      getPid(), thrd->getLWP());
1642          setLastError(err_notstopped, "All threads must be stopped to change fork tracking\n");
1643          return false;
1644       }
1645    }
1646    if (f == FollowFork::None) {
1647       perr_printf("Could not set fork tracking on %d to None\n", getPid());
1648       setLastError(err_badparam, "Cannot set fork tracking to None");
1649       return false;
1650    }
1651
1652    if (f == fork_tracking) {
1653       pthrd_printf("Leaving fork tracking for %d in state %d\n",
1654                    getPid(), (int) f);
1655       return true;
1656    }
1657
1658    for (i = threadPool()->begin(); i != threadPool()->end(); i++) {
1659       int_thread *thrd = *i;
1660       linux_thread *lthrd = dynamic_cast<linux_thread *>(thrd);
1661       pthrd_printf("Changing fork tracking for thread %d/%d to %d\n",
1662                    getPid(), lthrd->getLWP(), (int) f);
1663       lthrd->setOptions();
1664    }
1665    return true;
1666 }
1667
1668 FollowFork::follow_t linux_process::fork_isTracking() {
1669    return fork_tracking;
1670 }
1671
1672 bool linux_process::plat_lwpChangeTracking(bool) {
1673    int_threadPool *pool = threadPool();
1674    if (!pool->allStopped(int_thread::UserStateID)) {
1675       perr_printf("Attempted to change lwpTracking, but not all threads stopped in %d", getPid());
1676       setLastError(err_notstopped, "Process not stopped before changing LWP tracking state");
1677       return false;
1678    }
1679
1680    for (int_threadPool::iterator i = pool->begin(); i != pool->end(); i++) {
1681       int_thread *thrd = *i;
1682       linux_thread *lthrd = dynamic_cast<linux_thread *>(thrd);
1683       assert(lthrd);
1684       lthrd->setOptions();
1685    }
1686    return true;
1687 }
1688
1689 bool linux_process::allowSignal(int signal_no) {
1690    dyn_sigset_t mask = getSigMask();
1691    return sigismember(&mask, signal_no);
1692 }
1693
1694 bool linux_process::readStatM(unsigned long &stk, unsigned long &heap, unsigned long &shrd)
1695 {
1696    char path[64];
1697    snprintf(path, 64, "/proc/%d/statm", getPid());
1698    path[63] = '\0';
1699    
1700    unsigned long size, resident, shared, text, lib, data, dt;
1701    FILE *f = fopen(path, "r");
1702    if (!f) {
1703       perr_printf("Could not open %s: %s\n", path, strerror(errno));
1704       setLastError(err_internal, "Could not access /proc");
1705       return false;
1706    }
1707    fscanf(f, "%lu %lu %lu %lu %lu %lu %lu", &size, &resident, &shared, 
1708           &text, &lib, &data, &dt);
1709    fclose(f);
1710    unsigned long page_size = getpagesize();
1711
1712    stk = 0;
1713    shrd = (shared + text) * page_size;
1714    heap = data * page_size;
1715    return true;
1716 }
1717
1718 bool linux_process::plat_getStackUsage(MemUsageResp_t *resp)
1719 {
1720    unsigned long stk, heap, shrd;
1721    bool result = readStatM(stk, heap, shrd);
1722    if (!result) 
1723       return false;
1724    *resp->get() = stk;
1725    resp->done();
1726    return true;
1727 }
1728
1729 bool linux_process::plat_getHeapUsage(MemUsageResp_t *resp)
1730 {
1731    unsigned long stk, heap, shrd;
1732    bool result = readStatM(stk, heap, shrd);
1733    if (!result) 
1734       return false;
1735    *resp->get() = heap;
1736    resp->done();
1737    return true;
1738 }
1739
1740 bool linux_process::plat_getSharedUsage(MemUsageResp_t *resp)
1741 {
1742    unsigned long stk, heap, shrd;
1743    bool result = readStatM(stk, heap, shrd);
1744    if (!result) 
1745       return false;
1746    *resp->get() = shrd;
1747    resp->done();
1748    return true;
1749 }
1750
1751 bool linux_process::plat_residentNeedsMemVals()
1752 {
1753    return false;
1754 }
1755
1756 bool linux_process::plat_getResidentUsage(unsigned long, unsigned long, unsigned long,
1757                            MemUsageResp_t *)
1758 {
1759    return false;
1760 }
1761
1762 #if !defined(OFFSETOF)
1763 #define OFFSETOF(STR, FLD) (unsigned long) (&(((STR *) 0x0)->FLD))
1764 #endif
1765
1766 dynreg_to_user_t dynreg_to_user;
1767 static void init_dynreg_to_user()
1768 {
1769    static volatile bool initialized = false;
1770    static Mutex<> init_lock;
1771    if (initialized)
1772       return;
1773       
1774    init_lock.lock();
1775    if (initialized) {
1776       init_lock.unlock();
1777       return;
1778    }
1779     
1780    //Match the order of the 'user' structure to map registers correctly.
1781    int cur = 0;
1782    if (sizeof(void*) == 8) {
1783       /**
1784        * This is annoying, struct user is different for 64-bit processes debugging 
1785        * 32-bit processes.
1786        **/
1787       //r15
1788       cur+= 8; //r14
1789       cur+= 8; //r13
1790       cur+= 8; //r12
1791       dynreg_to_user[x86::ebp]   = make_pair(cur+=8, 4);
1792       dynreg_to_user[x86::ebx]   = make_pair(cur+=8, 4);
1793       cur+= 8; //r11
1794       cur+= 8; //r10
1795       cur+= 8; //r9
1796       cur+= 8; //r8
1797       dynreg_to_user[x86::eax]   = make_pair(cur+=8, 4);
1798       dynreg_to_user[x86::ecx]   = make_pair(cur+=8, 4);
1799       dynreg_to_user[x86::edx]   = make_pair(cur+=8, 4);
1800       dynreg_to_user[x86::esi]   = make_pair(cur+=8, 4);
1801       dynreg_to_user[x86::edi]   = make_pair(cur+=8, 4);
1802       dynreg_to_user[x86::oeax]  = make_pair(cur+=8, 4);
1803       dynreg_to_user[x86::eip]   = make_pair(cur+=8, 4);
1804       dynreg_to_user[x86::cs]    = make_pair(cur+=8, 4);
1805       dynreg_to_user[x86::flags] = make_pair(cur+=8, 4);
1806       dynreg_to_user[x86::esp]   = make_pair(cur+=8, 4);
1807       dynreg_to_user[x86::ss]    = make_pair(cur+=8, 4);
1808       dynreg_to_user[x86::fsbase]= make_pair(cur+=8, 4);
1809       dynreg_to_user[x86::gsbase]= make_pair(cur+=8, 4);
1810       dynreg_to_user[x86::ds]    = make_pair(cur+=8, 4);
1811       dynreg_to_user[x86::es]    = make_pair(cur+=8, 4);
1812       dynreg_to_user[x86::fs]    = make_pair(cur+=8, 4);
1813       dynreg_to_user[x86::gs]    = make_pair(cur+=8, 4);
1814 #if defined(arch_x86) || defined(arch_x86_64)
1815       cur = OFFSETOF(user, u_debugreg);
1816 #endif
1817       dynreg_to_user[x86::dr0]   = make_pair(cur, 4);
1818       dynreg_to_user[x86::dr1]   = make_pair(cur+=8, 4);
1819       dynreg_to_user[x86::dr2]   = make_pair(cur+=8, 4);
1820       dynreg_to_user[x86::dr3]   = make_pair(cur+=8, 4);
1821       dynreg_to_user[x86::dr4]   = make_pair(cur+=8, 4);
1822       dynreg_to_user[x86::dr5]   = make_pair(cur+=8, 4);
1823       dynreg_to_user[x86::dr6]   = make_pair(cur+=8, 4);
1824       dynreg_to_user[x86::dr7]   = make_pair(cur+=8, 4);
1825    }
1826    else {
1827       dynreg_to_user[x86::ebx]   = make_pair(cur, 4);
1828       dynreg_to_user[x86::ecx]   = make_pair(cur+=4, 4);
1829       dynreg_to_user[x86::edx]   = make_pair(cur+=4, 4);
1830       dynreg_to_user[x86::esi]   = make_pair(cur+=4, 4);
1831       dynreg_to_user[x86::edi]   = make_pair(cur+=4, 4);
1832       dynreg_to_user[x86::ebp]   = make_pair(cur+=4, 4);
1833       dynreg_to_user[x86::eax]   = make_pair(cur+=4, 4);
1834       dynreg_to_user[x86::ds]    = make_pair(cur+=4, 4);
1835       dynreg_to_user[x86::es]    = make_pair(cur+=4, 4);
1836       dynreg_to_user[x86::fs]    = make_pair(cur+=4, 4);
1837       dynreg_to_user[x86::gs]    = make_pair(cur+=4, 4);
1838       dynreg_to_user[x86::oeax]  = make_pair(cur+=4, 4);
1839       dynreg_to_user[x86::eip]   = make_pair(cur+=4, 4);
1840       dynreg_to_user[x86::cs]    = make_pair(cur+=4, 4);
1841       dynreg_to_user[x86::flags] = make_pair(cur+=4, 4);
1842       dynreg_to_user[x86::esp]   = make_pair(cur+=4, 4);
1843       dynreg_to_user[x86::ss]    = make_pair(cur+=4, 4);
1844 #if defined(arch_x86) || defined(arch_x86_64)
1845       cur = OFFSETOF(user, u_debugreg);
1846 #endif
1847       dynreg_to_user[x86::dr0]   = make_pair(cur, 4);
1848       dynreg_to_user[x86::dr1]   = make_pair(cur+=4, 4);
1849       dynreg_to_user[x86::dr2]   = make_pair(cur+=4, 4);
1850       dynreg_to_user[x86::dr3]   = make_pair(cur+=4, 4);
1851       dynreg_to_user[x86::dr4]   = make_pair(cur+=4, 4);
1852       dynreg_to_user[x86::dr5]   = make_pair(cur+=4, 4);
1853       dynreg_to_user[x86::dr6]   = make_pair(cur+=4, 4);
1854       dynreg_to_user[x86::dr7]   = make_pair(cur+=4, 4);
1855    }
1856    cur = 0;
1857    dynreg_to_user[x86_64::r15]    = make_pair(cur, 8);
1858    dynreg_to_user[x86_64::r14]    = make_pair(cur+=8, 8);
1859    dynreg_to_user[x86_64::r13]    = make_pair(cur+=8, 8);
1860    dynreg_to_user[x86_64::r12]    = make_pair(cur+=8, 8);
1861    dynreg_to_user[x86_64::rbp]    = make_pair(cur+=8, 8);
1862    dynreg_to_user[x86_64::rbx]    = make_pair(cur+=8, 8);
1863    dynreg_to_user[x86_64::r11]    = make_pair(cur+=8, 8);
1864    dynreg_to_user[x86_64::r10]    = make_pair(cur+=8, 8);
1865    dynreg_to_user[x86_64::r9]     = make_pair(cur+=8, 8);
1866    dynreg_to_user[x86_64::r8]     = make_pair(cur+=8, 8);
1867    dynreg_to_user[x86_64::rax]    = make_pair(cur+=8, 8);
1868    dynreg_to_user[x86_64::rcx]    = make_pair(cur+=8, 8);
1869    dynreg_to_user[x86_64::rdx]    = make_pair(cur+=8, 8);
1870    dynreg_to_user[x86_64::rsi]    = make_pair(cur+=8, 8);
1871    dynreg_to_user[x86_64::rdi]    = make_pair(cur+=8, 8);
1872    dynreg_to_user[x86_64::orax]   = make_pair(cur+=8, 8);
1873    dynreg_to_user[x86_64::rip]    = make_pair(cur+=8, 8);
1874    dynreg_to_user[x86_64::cs]     = make_pair(cur+=8, 8);
1875    dynreg_to_user[x86_64::flags]  = make_pair(cur+=8, 8);
1876    dynreg_to_user[x86_64::rsp]    = make_pair(cur+=8, 8);
1877    dynreg_to_user[x86_64::ss]     = make_pair(cur+=8, 8);
1878    dynreg_to_user[x86_64::fsbase] = make_pair(cur+=8, 8);
1879    dynreg_to_user[x86_64::gsbase] = make_pair(cur+=8, 8);
1880    dynreg_to_user[x86_64::ds]     = make_pair(cur+=8, 8);
1881    dynreg_to_user[x86_64::es]     = make_pair(cur+=8, 8);
1882    dynreg_to_user[x86_64::fs]     = make_pair(cur+=8, 8);
1883    dynreg_to_user[x86_64::gs]     = make_pair(cur+=8, 8);
1884 #if defined(arch_x86) || defined(arch_x86_64)
1885    cur = OFFSETOF(user, u_debugreg);
1886 #endif
1887    dynreg_to_user[x86_64::dr0]   = make_pair(cur, 8);
1888    dynreg_to_user[x86_64::dr1]   = make_pair(cur+=8, 8);
1889    dynreg_to_user[x86_64::dr2]   = make_pair(cur+=8, 8);
1890    dynreg_to_user[x86_64::dr3]   = make_pair(cur+=8, 8);
1891    dynreg_to_user[x86_64::dr4]   = make_pair(cur+=8, 8);
1892    dynreg_to_user[x86_64::dr5]   = make_pair(cur+=8, 8);
1893    dynreg_to_user[x86_64::dr6]   = make_pair(cur+=8, 8);
1894    dynreg_to_user[x86_64::dr7]   = make_pair(cur+=8, 8);
1895  
1896    cur = 0;
1897    if(sizeof(void *) == 8 ) {
1898        dynreg_to_user[ppc32::r0]        = make_pair(cur, 4);
1899        dynreg_to_user[ppc32::r1]        = make_pair(cur+=8, 4);
1900        dynreg_to_user[ppc32::r2]        = make_pair(cur+=8, 4);
1901        dynreg_to_user[ppc32::r3]        = make_pair(cur+=8, 4);
1902        dynreg_to_user[ppc32::r4]        = make_pair(cur+=8, 4);
1903        dynreg_to_user[ppc32::r5]        = make_pair(cur+=8, 4);
1904        dynreg_to_user[ppc32::r6]        = make_pair(cur+=8, 4);
1905        dynreg_to_user[ppc32::r7]        = make_pair(cur+=8, 4);
1906        dynreg_to_user[ppc32::r8]        = make_pair(cur+=8, 4);
1907        dynreg_to_user[ppc32::r9]        = make_pair(cur+=8, 4);
1908        dynreg_to_user[ppc32::r10]        = make_pair(cur+=8, 4);
1909        dynreg_to_user[ppc32::r11]        = make_pair(cur+=8, 4);
1910        dynreg_to_user[ppc32::r12]        = make_pair(cur+=8, 4);
1911        dynreg_to_user[ppc32::r13]        = make_pair(cur+=8, 4);
1912        dynreg_to_user[ppc32::r14]        = make_pair(cur+=8, 4);
1913        dynreg_to_user[ppc32::r15]        = make_pair(cur+=8, 4);
1914        dynreg_to_user[ppc32::r16]        = make_pair(cur+=8, 4);
1915        dynreg_to_user[ppc32::r17]        = make_pair(cur+=8, 4);
1916        dynreg_to_user[ppc32::r18]        = make_pair(cur+=8, 4);
1917        dynreg_to_user[ppc32::r19]        = make_pair(cur+=8, 4);
1918        dynreg_to_user[ppc32::r20]        = make_pair(cur+=8, 4);
1919        dynreg_to_user[ppc32::r21]        = make_pair(cur+=8, 4);
1920        dynreg_to_user[ppc32::r22]        = make_pair(cur+=8, 4);
1921        dynreg_to_user[ppc32::r23]        = make_pair(cur+=8, 4);
1922        dynreg_to_user[ppc32::r24]        = make_pair(cur+=8, 4);
1923        dynreg_to_user[ppc32::r25]        = make_pair(cur+=8, 4);
1924        dynreg_to_user[ppc32::r26]        = make_pair(cur+=8, 4);
1925        dynreg_to_user[ppc32::r27]        = make_pair(cur+=8, 4);
1926        dynreg_to_user[ppc32::r28]        = make_pair(cur+=8, 4);
1927        dynreg_to_user[ppc32::r29]        = make_pair(cur+=8, 4);
1928        dynreg_to_user[ppc32::r30]        = make_pair(cur+=8, 4);
1929        dynreg_to_user[ppc32::r31]        = make_pair(cur+=8, 4);
1930        dynreg_to_user[ppc32::pc]        = make_pair(cur+=8, 4);
1931        dynreg_to_user[ppc32::msr]        = make_pair(cur+=8, 4);
1932        dynreg_to_user[ppc32::or3]        = make_pair(cur+=8, 4);
1933        dynreg_to_user[ppc32::ctr]        = make_pair(cur+=8, 4);
1934        dynreg_to_user[ppc32::lr]        = make_pair(cur+=8, 4);
1935        dynreg_to_user[ppc32::xer]        = make_pair(cur+=8, 4);
1936        dynreg_to_user[ppc32::cr]        = make_pair(cur+=8, 4);
1937        dynreg_to_user[ppc32::mq]         = make_pair(cur+=8, 4);
1938        dynreg_to_user[ppc32::trap]       = make_pair(cur+=8, 4);
1939        dynreg_to_user[ppc32::dar]        = make_pair(cur+=8, 4);
1940        dynreg_to_user[ppc32::dsisr]      = make_pair(cur+=8, 4);
1941    }else{
1942        dynreg_to_user[ppc32::r0]        = make_pair(cur, 4);
1943        dynreg_to_user[ppc32::r1]        = make_pair(cur+=4, 4);
1944        dynreg_to_user[ppc32::r2]        = make_pair(cur+=4, 4);
1945        dynreg_to_user[ppc32::r3]        = make_pair(cur+=4, 4);
1946        dynreg_to_user[ppc32::r4]        = make_pair(cur+=4, 4);
1947        dynreg_to_user[ppc32::r5]        = make_pair(cur+=4, 4);
1948        dynreg_to_user[ppc32::r6]        = make_pair(cur+=4, 4);
1949        dynreg_to_user[ppc32::r7]        = make_pair(cur+=4, 4);
1950        dynreg_to_user[ppc32::r8]        = make_pair(cur+=4, 4);
1951        dynreg_to_user[ppc32::r9]        = make_pair(cur+=4, 4);
1952        dynreg_to_user[ppc32::r10]        = make_pair(cur+=4, 4);
1953        dynreg_to_user[ppc32::r11]        = make_pair(cur+=4, 4);
1954        dynreg_to_user[ppc32::r12]        = make_pair(cur+=4, 4);
1955        dynreg_to_user[ppc32::r13]        = make_pair(cur+=4, 4);
1956        dynreg_to_user[ppc32::r14]        = make_pair(cur+=4, 4);
1957        dynreg_to_user[ppc32::r15]        = make_pair(cur+=4, 4);
1958        dynreg_to_user[ppc32::r16]        = make_pair(cur+=4, 4);
1959        dynreg_to_user[ppc32::r17]        = make_pair(cur+=4, 4);
1960        dynreg_to_user[ppc32::r18]        = make_pair(cur+=4, 4);
1961        dynreg_to_user[ppc32::r19]        = make_pair(cur+=4, 4);
1962        dynreg_to_user[ppc32::r20]        = make_pair(cur+=4, 4);
1963        dynreg_to_user[ppc32::r21]        = make_pair(cur+=4, 4);
1964        dynreg_to_user[ppc32::r22]        = make_pair(cur+=4, 4);
1965        dynreg_to_user[ppc32::r23]        = make_pair(cur+=4, 4);
1966        dynreg_to_user[ppc32::r24]        = make_pair(cur+=4, 4);
1967        dynreg_to_user[ppc32::r25]        = make_pair(cur+=4, 4);
1968        dynreg_to_user[ppc32::r26]        = make_pair(cur+=4, 4);
1969        dynreg_to_user[ppc32::r27]        = make_pair(cur+=4, 4);
1970        dynreg_to_user[ppc32::r28]        = make_pair(cur+=4, 4);
1971        dynreg_to_user[ppc32::r29]        = make_pair(cur+=4, 4);
1972        dynreg_to_user[ppc32::r30]        = make_pair(cur+=4, 4);
1973        dynreg_to_user[ppc32::r31]        = make_pair(cur+=4, 4);
1974        dynreg_to_user[ppc32::pc]        = make_pair(cur+=4, 4);
1975        dynreg_to_user[ppc32::msr]        = make_pair(cur+=4, 4);
1976        dynreg_to_user[ppc32::or3]        = make_pair(cur+=4, 4);
1977        dynreg_to_user[ppc32::ctr]        = make_pair(cur+=4, 4);
1978        dynreg_to_user[ppc32::lr]        = make_pair(cur+=4, 4);
1979        dynreg_to_user[ppc32::xer]        = make_pair(cur+=4, 4);
1980        dynreg_to_user[ppc32::cr]        = make_pair(cur+=4, 4);
1981        dynreg_to_user[ppc32::mq]         = make_pair(cur+=4, 4);
1982        dynreg_to_user[ppc32::trap]       = make_pair(cur+=4, 4);
1983        dynreg_to_user[ppc32::dar]        = make_pair(cur+=4, 4);
1984        dynreg_to_user[ppc32::dsisr]      = make_pair(cur+=4, 4);
1985    }
1986    cur = 0;
1987    dynreg_to_user[ppc64::r0]        = make_pair(cur, 8);
1988    dynreg_to_user[ppc64::r1]        = make_pair(cur+=8, 8);
1989    dynreg_to_user[ppc64::r2]        = make_pair(cur+=8, 8);
1990    dynreg_to_user[ppc64::r3]        = make_pair(cur+=8, 8);
1991    dynreg_to_user[ppc64::r4]        = make_pair(cur+=8, 8);
1992    dynreg_to_user[ppc64::r5]        = make_pair(cur+=8, 8);
1993    dynreg_to_user[ppc64::r6]        = make_pair(cur+=8, 8);
1994    dynreg_to_user[ppc64::r7]        = make_pair(cur+=8, 8);
1995    dynreg_to_user[ppc64::r8]        = make_pair(cur+=8, 8);
1996    dynreg_to_user[ppc64::r9]        = make_pair(cur+=8, 8);
1997    dynreg_to_user[ppc64::r10]        = make_pair(cur+=8, 8);
1998    dynreg_to_user[ppc64::r11]        = make_pair(cur+=8, 8);
1999    dynreg_to_user[ppc64::r12]        = make_pair(cur+=8, 8);
2000    dynreg_to_user[ppc64::r13]        = make_pair(cur+=8, 8);
2001    dynreg_to_user[ppc64::r14]        = make_pair(cur+=8, 8);
2002    dynreg_to_user[ppc64::r15]        = make_pair(cur+=8, 8);
2003    dynreg_to_user[ppc64::r16]        = make_pair(cur+=8, 8);
2004    dynreg_to_user[ppc64::r17]        = make_pair(cur+=8, 8);
2005    dynreg_to_user[ppc64::r18]        = make_pair(cur+=8, 8);
2006    dynreg_to_user[ppc64::r19]        = make_pair(cur+=8, 8);
2007    dynreg_to_user[ppc64::r20]        = make_pair(cur+=8, 8);
2008    dynreg_to_user[ppc64::r21]        = make_pair(cur+=8, 8);
2009    dynreg_to_user[ppc64::r22]        = make_pair(cur+=8, 8);
2010    dynreg_to_user[ppc64::r23]        = make_pair(cur+=8, 8);
2011    dynreg_to_user[ppc64::r24]        = make_pair(cur+=8, 8);
2012    dynreg_to_user[ppc64::r25]        = make_pair(cur+=8, 8);
2013    dynreg_to_user[ppc64::r26]        = make_pair(cur+=8, 8);
2014    dynreg_to_user[ppc64::r27]        = make_pair(cur+=8, 8);
2015    dynreg_to_user[ppc64::r28]        = make_pair(cur+=8, 8);
2016    dynreg_to_user[ppc64::r29]        = make_pair(cur+=8, 8);
2017    dynreg_to_user[ppc64::r30]        = make_pair(cur+=8, 8);
2018    dynreg_to_user[ppc64::r31]        = make_pair(cur+=8, 8);
2019    dynreg_to_user[ppc64::pc]        = make_pair(cur+=8, 8);
2020    dynreg_to_user[ppc64::msr]        = make_pair(cur+=8, 8);
2021    dynreg_to_user[ppc64::or3]        = make_pair(cur+=8, 8);
2022    dynreg_to_user[ppc64::ctr]        = make_pair(cur+=8, 8);
2023    dynreg_to_user[ppc64::lr]        = make_pair(cur+=8, 8);
2024    dynreg_to_user[ppc64::xer]        = make_pair(cur+=8, 8);
2025    dynreg_to_user[ppc64::cr]        = make_pair(cur+=8, 8);
2026    dynreg_to_user[ppc64::mq]         = make_pair(cur+=8, 8);
2027    dynreg_to_user[ppc64::trap]       = make_pair(cur+=8, 8);
2028    dynreg_to_user[ppc64::dar]        = make_pair(cur+=8, 8);
2029    dynreg_to_user[ppc64::dsisr]      = make_pair(cur+=8, 8);
2030
2031    initialized = true;
2032
2033    init_lock.unlock();
2034 }
2035
2036 #if defined(PT_GETREGS)
2037 #define MY_PTRACE_GETREGS PTRACE_GETREGS
2038 #elif defined(arch_power)
2039 //Kernel value for PPC_PTRACE_SETREGS 0x99
2040 #define MY_PTRACE_GETREGS 12
2041 #endif
2042
2043 //912 is currently the x86_64 size, 128 bytes for just-because padding
2044 #define MAX_USER_SIZE (912+128)
2045 bool linux_thread::plat_getAllRegisters(int_registerPool &regpool)
2046 {
2047    static bool have_getregs = true;
2048    static bool tested_getregs = false;
2049
2050 #if defined(bug_registers_after_exit)
2051    /* On some kernels, attempting to read registers from a thread in a pre-Exit
2052     * state causes an oops
2053     */
2054    if( isExiting() ) {
2055        perr_printf("Cannot reliably retrieve registers from an exited thread\n");
2056        setLastError(err_exited, "Cannot retrieve registers from an exited thread");
2057        return false;
2058    }
2059 #endif
2060
2061    volatile unsigned int sentinel1 = 0xfeedface;
2062    unsigned char user_area[MAX_USER_SIZE];
2063    volatile unsigned int sentinel2 = 0xfeedface;
2064    memset(user_area, 0, MAX_USER_SIZE);
2065
2066    Dyninst::Architecture curplat = llproc()->getTargetArch();
2067    init_dynreg_to_user();
2068    dynreg_to_user_t::iterator i;
2069
2070    if (have_getregs)
2071    {
2072       long result = do_ptrace((pt_req) MY_PTRACE_GETREGS, lwp, user_area, user_area);
2073       if (result != 0) {
2074          int error = errno;
2075          if (error == EIO && !tested_getregs) {
2076             pthrd_printf("PTRACE_GETREGS not working.  Trying PTRACE_PEEKUSER\n");
2077             have_getregs = false;
2078          }
2079          else {
2080             perr_printf("Error reading registers from %d\n", lwp);
2081             setLastError(err_internal, "Could not read user area from thread");
2082             return false;
2083          }
2084       }
2085       tested_getregs = true;
2086    }
2087    if (!have_getregs)
2088    {
2089       for (i = dynreg_to_user.begin(); i != dynreg_to_user.end(); i++) {
2090          const MachRegister reg = i->first;
2091          if (reg.getArchitecture() != curplat)
2092             continue;
2093          long result = do_ptrace((pt_req) PTRACE_PEEKUSER, lwp, (void *) (unsigned long) i->second.first, NULL);
2094          if (errno == -1) {
2095             perr_printf("Error reading registers from %d at %x\n", lwp, i->second.first);
2096             setLastError(err_internal, "Could not read user area from thread");
2097             return false;
2098          }
2099          if (Dyninst::getArchAddressWidth(curplat) == 4) {
2100             uint32_t val = (uint32_t) result;
2101             *((uint32_t *) (user_area + i->second.first)) = val;
2102          }
2103          else if (Dyninst::getArchAddressWidth(curplat) == 8) {
2104             uint64_t val = (uint64_t) result;
2105             *((uint64_t *) (user_area + i->second.first)) = val;
2106          }
2107          else {
2108             assert(0);
2109          }
2110       }
2111    }
2112
2113    //If a sentinel assert fails, then someone forgot to increase MAX_USER_SIZE
2114    // for a new platform.
2115    assert(sentinel1 == 0xfeedface);
2116    assert(sentinel2 == 0xfeedface);
2117    if(sentinel1 != 0xfeedface || sentinel2 != 0xfeedface) return false;
2118    
2119
2120    regpool.regs.clear();
2121    for (i = dynreg_to_user.begin(); i != dynreg_to_user.end(); i++)
2122    {
2123       const MachRegister reg = i->first;
2124       MachRegisterVal val = 0;
2125       if (reg.getArchitecture() != curplat)
2126          continue;
2127       const unsigned int offset = i->second.first;
2128       const unsigned int size = i->second.second;
2129       if (size == 4) {
2130          if( sizeof(void *) == 8 ) {
2131             // Avoid endian issues
2132             uint64_t tmpVal = *((uint64_t *) (user_area+offset));
2133             val = (uint32_t) tmpVal;
2134          }else{
2135             val = *((uint32_t *) (user_area+offset));
2136          }
2137       }
2138       else if (size == 8) {
2139          val = *((uint64_t *) (user_area+offset));
2140       }
2141       else {
2142          assert(0);
2143       }
2144
2145      pthrd_printf("Register %s has value %lx, offset %d\n", reg.name().c_str(), val, offset);
2146       regpool.regs[reg] = val;
2147    }
2148    return true;
2149 }
2150
2151 bool linux_thread::plat_getRegister(Dyninst::MachRegister reg, Dyninst::MachRegisterVal &val)
2152 {
2153 #if defined(bug_registers_after_exit)
2154    /* On some kernels, attempting to read registers from a thread in a pre-Exit
2155     * state causes an oops
2156     */
2157    if( isExiting() ) {
2158        perr_printf("Cannot reliably retrieve registers from an exited thread\n");
2159        setLastError(err_exited, "Cannot retrieve registers from an exited thread");
2160        return false;
2161    }
2162 #endif
2163
2164    if (x86::fsbase == reg || x86::gsbase == reg 
2165        || x86_64::fsbase == reg || x86_64::gsbase == reg) {
2166       return getSegmentBase(reg, val);
2167    }
2168
2169    init_dynreg_to_user();
2170    dynreg_to_user_t::iterator i = dynreg_to_user.find(reg);
2171    if (i == dynreg_to_user.end() || reg.getArchitecture() != llproc()->getTargetArch()) {
2172       perr_printf("Recieved unexpected register %s on thread %d\n", reg.name().c_str(), lwp);
2173       setLastError(err_badparam, "Invalid register");
2174       return false;
2175    }
2176
2177    const unsigned offset = i->second.first;
2178    const unsigned size = i->second.second;
2179    assert(sizeof(val) >= size);
2180    if(sizeof(val) < size) return false;
2181    
2182    val = 0;
2183    unsigned long result = do_ptrace((pt_req) PTRACE_PEEKUSER, lwp, (void *) (unsigned long) offset, NULL);
2184    if (errno != 0) {
2185       perr_printf("Error reading registers from %d: %s\n", lwp, strerror(errno));
2186       setLastError(err_internal, "Could not read register from thread");
2187       return false;
2188    }
2189    val = result;
2190
2191    pthrd_printf("Register %s has value 0x%lx\n", reg.name().c_str(), val);
2192    return true;
2193 }
2194
2195 #if defined(PT_SETREGS)
2196 #define MY_PTRACE_SETREGS PT_SETREGS
2197 #else
2198 //Common kernel value for PTRACE_SETREGS
2199 #define MY_PTRACE_SETREGS 13
2200 #endif
2201
2202 bool linux_thread::plat_setAllRegisters(int_registerPool &regpool) 
2203 {
2204    static bool have_setregs = true;
2205    static bool tested_setregs = false;
2206 #if defined(bug_registers_after_exit)
2207    /* On some kernels, attempting to read registers from a thread in a pre-Exit
2208     * state causes an oops
2209     */
2210    if( isExiting() ) {
2211        perr_printf("Cannot reliably retrieve registers from an exited thread\n");
2212        setLastError(err_exited, "Cannot retrieve registers from an exited thread");
2213        return false;
2214    }
2215 #endif
2216    
2217
2218    if (have_setregs)
2219    {
2220       unsigned char user_area[MAX_USER_SIZE];
2221       //Fill in 'user_area' with the contents of regpool.   
2222       if( !plat_convertToSystemRegs(regpool, user_area) ) return false;
2223       
2224       //Double up the user_area parameter because if MY_PTRACE_SETREGS is
2225       // defined to PPC_PTRACE_SETREGS than the parameters data and addr
2226       // pointers get swapped (just because linux hates us).  Since the 
2227       // other is ignored, we pass it in twice.
2228       int result = do_ptrace((pt_req) MY_PTRACE_SETREGS, lwp, user_area, user_area);
2229       if (result != 0) {
2230          int error = errno;
2231          if (error == EIO && !tested_setregs) {
2232             pthrd_printf("PTRACE_SETREGS not working.  Trying PTRACE_POKEUSER\n");
2233             have_setregs = false;
2234          }
2235          else {
2236             perr_printf("Error setting registers for %d\n", lwp);
2237             setLastError(err_internal, "Could not read user area from thread");
2238             return false;
2239          }
2240       }
2241       tested_setregs = true;
2242    }
2243    if (!have_setregs)
2244    {
2245       Dyninst::Architecture curplat = llproc()->getTargetArch();
2246       init_dynreg_to_user();
2247       for (int_registerPool::iterator i = regpool.regs.begin(); i != regpool.regs.end(); i++) {
2248          assert(i->first.getArchitecture() == curplat);
2249          dynreg_to_user_t::iterator di = dynreg_to_user.find(i->first);
2250          assert(di != dynreg_to_user.end());
2251          
2252          //Don't treat errors on these registers as real errors.
2253          bool not_present = true;
2254          if (curplat == Arch_ppc32)
2255             not_present = (i->first == ppc32::mq || i->first == ppc32::dar || 
2256                            i->first == ppc32::dsisr || i->first == ppc32::trap ||
2257                            i->first == ppc32::or3);
2258          
2259          if (not_present)
2260             continue;
2261          
2262          int result;
2263          uintptr_t res;
2264          if (Dyninst::getArchAddressWidth(curplat) == 4) {
2265             res = (uint32_t) i->second;
2266          }
2267          else {
2268             res = (uint64_t) i->second;
2269          }
2270          result = do_ptrace((pt_req) PTRACE_POKEUSER, lwp, (void *) (unsigned long) di->second.first, (void *) res);
2271          
2272          if (result != 0) {
2273             int error = errno;
2274             perr_printf("Error setting register %s for %d at %d: %s\n", i->first.name().c_str(),
2275                         lwp, (int) di->second.first, strerror(error));
2276             setLastError(err_internal, "Could not read user area from thread");
2277             return false;
2278          }
2279       }
2280    }
2281
2282    pthrd_printf("Successfully set the values of all registers for %d\n", lwp);
2283    return true;
2284 }
2285
2286 bool linux_thread::plat_convertToSystemRegs(const int_registerPool &regpool, unsigned char *user_area,
2287                                             bool gprs_only)
2288 {
2289    init_dynreg_to_user();
2290
2291    Architecture curplat = llproc()->getTargetArch();
2292    unsigned num_found = 0;
2293    for (dynreg_to_user_t::const_iterator i = dynreg_to_user.begin(); i != dynreg_to_user.end(); i++)
2294    {
2295       const MachRegister reg = i->first;
2296       MachRegisterVal val;
2297       if (reg.getArchitecture() != curplat)
2298          continue;
2299
2300       if (gprs_only) {
2301          bool is_gpr;
2302          int rclass = (int) reg.regClass();
2303
2304          switch (llproc()->getTargetArch()) {
2305             //In this case our definition of GPR is anything stored in the elf_gregset_t of 
2306             // the user struct.
2307             case Dyninst::Arch_x86:
2308                is_gpr = ((rclass == x86::GPR) || (rclass == x86::FLAG) || 
2309                          (rclass == x86::MISC) || (rclass == x86::SEG) || !rclass);
2310                break;
2311             case Dyninst::Arch_x86_64:
2312                is_gpr = ((rclass == x86_64::GPR) || (rclass == x86_64::FLAG) || 
2313                          (rclass == x86_64::MISC) || (rclass == x86_64::SEG) || !rclass);
2314                break;
2315             case Dyninst::Arch_ppc32:
2316                is_gpr = true;
2317                break;
2318             case Dyninst::Arch_ppc64:
2319                is_gpr = true;
2320                break;
2321             default:
2322                assert(0);
2323                return false;
2324          }
2325
2326          if (!is_gpr) {
2327             continue;
2328          }
2329       }
2330
2331       num_found++;
2332       const unsigned int offset = i->second.first;
2333       const unsigned int size = i->second.second;
2334       assert(offset+size < MAX_USER_SIZE);
2335
2336       if ((offset+size) > sizeof(prgregset_t)) continue;
2337       
2338       int_registerPool::reg_map_t::const_iterator j = regpool.regs.find(reg);
2339       assert(j != regpool.regs.end());
2340       val = j->second;
2341       
2342       if (size == 4) {
2343           if( sizeof(void *) == 8 ) {
2344               *((uint64_t *) (user_area+offset)) = (uint64_t) val;
2345           } else {
2346               *((uint32_t *) (user_area+offset)) = (uint32_t) val;
2347           }
2348       }
2349       else if (size == 8) {
2350          *((uint64_t *) (user_area+offset)) = (uint64_t) val;
2351       }
2352       else {
2353          assert(0);
2354       }
2355       pthrd_printf("Register %s gets value %lx, offset %d\n", reg.name().c_str(), val, offset);
2356    }
2357
2358    if (!gprs_only && (num_found != regpool.regs.size()))
2359    {
2360       setLastError(err_badparam, "Invalid register set passed to setAllRegisters");
2361       perr_printf("Couldn't find all registers in the register set %u/%u\n", num_found,
2362                   (unsigned int) regpool.regs.size());
2363       return false;
2364    }
2365
2366    return true;
2367 }
2368
2369 bool linux_thread::plat_setRegister(Dyninst::MachRegister reg, Dyninst::MachRegisterVal val)
2370 {
2371 #if defined(bug_registers_after_exit)
2372    /* On some kernels, attempting to read registers from a thread in a pre-Exit
2373     * state causes an oops
2374     */
2375    if( isExiting() ) {
2376        perr_printf("Cannot reliably retrieve registers from an exited thread\n");
2377        setLastError(err_exited, "Cannot retrieve registers from an exited thread");
2378        return false;
2379    }
2380 #endif
2381
2382    init_dynreg_to_user();
2383    dynreg_to_user_t::iterator i = dynreg_to_user.find(reg);
2384    if (reg.getArchitecture() != llproc()->getTargetArch() ||
2385        i == dynreg_to_user.end()) 
2386    {
2387       setLastError(err_badparam, "Invalid register passed to setRegister");
2388       perr_printf("User passed invalid register %s to plat_setRegister, arch is %x\n",
2389                   reg.name().c_str(), (unsigned int) reg.getArchitecture());
2390       return false;
2391    }
2392    
2393    const unsigned int offset = i->second.first;
2394    const unsigned int size = i->second.second;
2395    int result;
2396    uintptr_t value;
2397    if (size == 4) {
2398       value = (uint32_t) val;
2399    }
2400    else if (size == 8) {
2401       value = (uint64_t) val;
2402    }
2403    else {
2404       assert(0);
2405       return false;
2406       
2407    }
2408    result = do_ptrace((pt_req) PTRACE_POKEUSER, lwp, (void *) (uintptr_t)offset, (void *) value);
2409    pthrd_printf("Set register %s (size %u, offset %u) to value %lx\n", reg.name().c_str(), size, offset, val);
2410    if (result != 0) {
2411       int error = errno;
2412       setLastError(err_internal, "Could not set register value");
2413       perr_printf("Unable to set value of register %s in thread %d: %s (%d)\n",
2414                   reg.name().c_str(), lwp, strerror(error), error);
2415       return false;
2416    }
2417    
2418    return true;
2419 }
2420
2421 bool linux_thread::plat_getAllRegistersAsync(allreg_response::ptr result)
2422 {
2423    bool b = plat_getAllRegisters(*result->getRegPool());
2424    if (!b) {
2425       result->markError(getLastError());
2426    }
2427    fake_async_msgs.push_back(result->getID());
2428    return true;
2429 }
2430
2431 bool linux_thread::plat_getRegisterAsync(Dyninst::MachRegister reg, 
2432                                          reg_response::ptr result)
2433 {
2434    Dyninst::MachRegisterVal val = 0;
2435    bool b = plat_getRegister(reg, val);
2436    result->val = val;
2437    if (!b) {
2438       result->markError(getLastError());
2439    }
2440    fake_async_msgs.push_back(result->getID());
2441    return true;
2442 }
2443
2444 bool linux_thread::plat_setAllRegistersAsync(int_registerPool &pool,
2445                                              result_response::ptr result)
2446 {
2447    bool b = plat_setAllRegisters(pool);
2448    if (!b) {
2449       result->markError(getLastError());
2450       result->b = false;
2451    }
2452    else {
2453       result->b = true;
2454    }
2455    fake_async_msgs.push_back(result->getID());
2456    return true;
2457 }
2458
2459 bool linux_thread::plat_setRegisterAsync(Dyninst::MachRegister reg, 
2460                                          Dyninst::MachRegisterVal val,
2461                                          result_response::ptr result)
2462 {
2463    bool b = plat_setRegister(reg, val);
2464    if (!b) {
2465       result->markError(getLastError());
2466       result->b = false;
2467    }
2468    else {
2469       result->b = true;
2470    }
2471    fake_async_msgs.push_back(result->getID());
2472    return true;
2473 }
2474
2475 bool linux_thread::attach()
2476 {
2477    if (llproc()->threadPool()->initialThread() == this) {
2478       return true;
2479    }
2480
2481    if (attach_status != as_needs_attach)
2482    {
2483       pthrd_printf("thread::attach called on running thread %d/%d, should " 
2484                    "be auto-attached.\n", llproc()->getPid(), lwp);
2485       return true;
2486    }
2487
2488    pthrd_printf("Calling PTRACE_ATTACH on thread %d/%d\n", 
2489                 llproc()->getPid(), lwp);
2490    int result = do_ptrace((pt_req) PTRACE_ATTACH, lwp, NULL, NULL);
2491    if (result != 0) {
2492       perr_printf("Failed to attach to thread: %s\n", strerror(errno));
2493       setLastError(err_internal, "Failed to attach to thread");
2494       return false;
2495    }
2496    return true;
2497 }
2498
2499 #if !defined(ARCH_GET_FS)
2500 #define ARCH_GET_FS 0x1003
2501 #endif
2502 #if !defined(ARCH_GET_GS)
2503 #define ARCH_GET_GS 0x1004
2504 #endif
2505 #if !defined(PTRACE_GET_THREAD_AREA)
2506 #define PTRACE_GET_THREAD_AREA 25
2507 #endif
2508 #if !defined(PTRACE_ARCH_PRCTL)
2509 #define PTRACE_ARCH_PRCTL 30
2510 #endif
2511 #define FS_REG_NUM 25
2512 #define GS_REG_NUM 26
2513
2514 bool linux_thread::thrdb_getThreadArea(int val, Dyninst::Address &addr)
2515 {
2516    Dyninst::Architecture arch = llproc()->getTargetArch();
2517    switch (arch) {
2518       case Arch_x86: {
2519          uint32_t addrv[4];
2520          int result = do_ptrace((pt_req) PTRACE_GET_THREAD_AREA, lwp, (void *) (intptr_t)val, &addrv);
2521          if (result != 0) {
2522             int error = errno;
2523             perr_printf("Error doing PTRACE_GET_THREAD_AREA on %d/%d: %s\n", llproc()->getPid(), lwp, strerror(error));
2524             setLastError(err_internal, "Error doing PTRACE_GET_THREAD_AREA\n");
2525             return false;
2526          }
2527          addr = (Dyninst::Address) addrv[1];
2528          break;
2529       }
2530       case Arch_x86_64: {
2531          intptr_t op;
2532          if (val == FS_REG_NUM)
2533             op = ARCH_GET_FS;
2534          else if (val == GS_REG_NUM)
2535             op = ARCH_GET_GS;
2536          else {
2537             perr_printf("Bad value (%d) passed to thrdb_getThreadArea\n", val);
2538             return false;
2539          }
2540          uint64_t addrv = 0;
2541          int result = do_ptrace((pt_req) PTRACE_ARCH_PRCTL, lwp, &addrv, (void *) op);
2542          if (result != 0) {
2543             int error = errno;
2544             perr_printf("Error doing PTRACE_ARCH_PRCTL on %d/%d: %s\n", llproc()->getPid(), lwp, strerror(error));
2545             setLastError(err_internal, "Error doing PTRACE_ARCH_PRCTL\n");
2546             return false;
2547          }
2548          addr = (Dyninst::Address) addrv;
2549          break;
2550       }
2551       default:
2552          assert(0); //Should not be needed on non-x86
2553    }
2554    return true;
2555 }
2556
2557 //Copied from /usr/include/asm/ldt.h, as it was not available on all machines
2558 struct linux_x86_user_desc {
2559    unsigned int  entry_number;   
2560    unsigned long base_addr;
2561    unsigned int  limit;
2562    unsigned int  seg_32bit:1;
2563    unsigned int  contents:2;
2564    unsigned int  read_exec_only:1;
2565    unsigned int  limit_in_pages:1;
2566    unsigned int  seg_not_present:1;
2567    unsigned int  useable:1;
2568 };
2569
2570 bool linux_thread::getSegmentBase(Dyninst::MachRegister reg, Dyninst::MachRegisterVal &val)
2571 {
2572    switch (llproc()->getTargetArch())
2573    {
2574       case Arch_x86_64:
2575          // TODO
2576          // use ptrace_arch_prctl     
2577          pthrd_printf("Segment bases on x86_64 not implemented\n");
2578          return false;
2579       case Arch_x86: {
2580          MachRegister segmentSelectorReg;
2581          MachRegisterVal segmentSelectorVal;
2582          unsigned long entryNumber;
2583          struct linux_x86_user_desc entryDesc;
2584
2585          switch (reg.val())
2586          {
2587             case x86::ifsbase: segmentSelectorReg = x86::fs; break;
2588             case x86::igsbase: segmentSelectorReg = x86::gs; break;
2589             default: {
2590                pthrd_printf("Failed to get unrecognized segment base\n");
2591                return false;
2592             }
2593          }
2594
2595          if (!plat_getRegister(segmentSelectorReg, segmentSelectorVal))
2596          {
2597            pthrd_printf("Failed to get segment base with selector %s\n", segmentSelectorReg.name().c_str());
2598            return false;
2599          }
2600          entryNumber = segmentSelectorVal / 8;
2601
2602          pthrd_printf("Get segment base doing PTRACE with entry %lu\n", entryNumber);
2603          long result = do_ptrace((pt_req) PTRACE_GET_THREAD_AREA, 
2604                                  lwp, (void *) entryNumber, (void *) &entryDesc);
2605          if (result == -1 && errno != 0) {
2606             pthrd_printf("PTRACE to get segment base failed: %s\n", strerror(errno));
2607             return false;
2608          }
2609
2610          val = entryDesc.base_addr;
2611          pthrd_printf("Got segment base: 0x%lx\n", val);
2612          return true;
2613       }
2614       default:
2615          assert(!"This is not implemented on this architecture");
2616          return false;
2617    }
2618  }
2619
2620 linux_x86_thread::linux_x86_thread(int_process *p, Dyninst::THR_ID t, Dyninst::LWP l) :
2621    int_thread(p, t, l),
2622    thread_db_thread(p, t, l),
2623    linux_thread(p, t, l),
2624    x86_thread(p, t, l)
2625 {
2626 }
2627
2628 linux_x86_thread::~linux_x86_thread()
2629 {
2630 }
2631
2632 linux_ppc_thread::linux_ppc_thread(int_process *p, Dyninst::THR_ID t, Dyninst::LWP l) :
2633    int_thread(p, t, l),
2634    thread_db_thread(p, t, l),
2635    linux_thread(p, t, l),
2636    ppc_thread(p, t, l)
2637 {
2638 }
2639
2640 linux_ppc_thread::~linux_ppc_thread()
2641 {
2642 }
2643
2644 ArchEventLinux::ArchEventLinux(bool inter_) : 
2645    status(0),
2646    pid(NULL_PID),
2647    interrupted(inter_),
2648    error(0),
2649    child_pid(NULL_PID),
2650    event_ext(0)
2651 {
2652 }
2653
2654 ArchEventLinux::ArchEventLinux(pid_t p, int s) : 
2655    status(s),
2656    pid(p), 
2657    interrupted(false), 
2658    error(0),
2659    child_pid(NULL_PID),
2660    event_ext(0)
2661 {
2662 }
2663
2664 ArchEventLinux::ArchEventLinux(int e) : 
2665    status(0),
2666    pid(NULL_PID),
2667    interrupted(false),
2668    error(e),
2669    child_pid(NULL_PID),
2670    event_ext(0)
2671 {
2672 }
2673       
2674 ArchEventLinux::~ArchEventLinux()
2675 {
2676 }
2677
2678 std::vector<ArchEventLinux *> ArchEventLinux::pending_events;
2679
2680 bool ArchEventLinux::findPairedEvent(ArchEventLinux* &parent, ArchEventLinux* &child)
2681 {
2682    bool is_parent;
2683    if (WIFSTOPPED(status) && WSTOPSIG(status) == SIGTRAP) {
2684       //'this' event is a parent, search list for a child
2685       is_parent = true;
2686    }
2687    else if (WIFSTOPPED(status) && WSTOPSIG(status) == SIGSTOP) {
2688       //'this' event  is a child, search list for a parent
2689       is_parent = false;
2690    }
2691    else 
2692    {
2693       assert(0);
2694       return false;
2695    }
2696    
2697    vector<ArchEventLinux *>::iterator i;
2698    for (i = pending_events.begin(); i != pending_events.end(); i++) {
2699       parent = is_parent ? this : *i;
2700       child = is_parent ? *i : this;
2701       if (parent->child_pid == child->pid) {
2702          pending_events.erase(i);
2703          return true;
2704       }
2705    }
2706    return false;
2707 }
2708
2709 void ArchEventLinux::postponePairedEvent()
2710 {
2711    pending_events.push_back(this);
2712 }
2713
2714 LinuxHandleNewThr::LinuxHandleNewThr() :
2715    Handler("Linux New Thread")
2716 {
2717 }
2718
2719 LinuxHandleNewThr::~LinuxHandleNewThr()
2720 {
2721 }
2722
2723 Handler::handler_ret_t LinuxHandleNewThr::handleEvent(Event::ptr ev)
2724 {
2725    linux_thread *thr = NULL;
2726    if (ev->getEventType().code() == EventType::Bootstrap) {
2727       thr = dynamic_cast<linux_thread *>(ev->getThread()->llthrd());
2728    }
2729    else if (ev->getEventType().code() == EventType::ThreadCreate) {
2730       Dyninst::LWP lwp = static_cast<EventNewThread *>(ev.get())->getLWP();
2731       ProcPool()->condvar()->lock();
2732       thr = dynamic_cast<linux_thread *>(ProcPool()->findThread(lwp));
2733       ProcPool()->condvar()->unlock();
2734    }
2735    assert(thr);
2736                                         
2737    pthrd_printf("Setting ptrace options for new thread %d\n", thr->getLWP());
2738    thr->setOptions();
2739    return ret_success;
2740 }
2741
2742 int LinuxHandleNewThr::getPriority() const
2743 {
2744    return PostPlatformPriority;
2745 }
2746
2747 void LinuxHandleNewThr::getEventTypesHandled(std::vector<EventType> &etypes)
2748 {
2749    etypes.push_back(EventType(EventType::None, EventType::ThreadCreate));
2750    etypes.push_back(EventType(EventType::None, EventType::Bootstrap));
2751 }
2752
2753 LinuxHandleLWPDestroy::LinuxHandleLWPDestroy()
2754     : Handler("Linux LWP Destroy")
2755 {
2756 }
2757
2758 LinuxHandleLWPDestroy::~LinuxHandleLWPDestroy()
2759 {
2760 }
2761
2762 Handler::handler_ret_t LinuxHandleLWPDestroy::handleEvent(Event::ptr ev) {
2763     int_thread *thrd = ev->getThread()->llthrd();
2764
2765     // This handler is necessary because SIGSTOPS cannot be sent to pre-destroyed
2766     // threads -- these stops will never be delivered to the debugger
2767     //
2768     // Setting the exiting state in the thread will avoid any waiting for pending stops
2769     // on this thread
2770
2771     thrd->setExiting(true);
2772
2773     // If there is a pending stop, need to handle it here because there is
2774     // no guarantee that the stop will ever be received
2775     if( thrd->hasPendingStop() ) {
2776        thrd->setPendingStop(false);
2777     }
2778
2779     return ret_success;
2780 }
2781
2782 int LinuxHandleLWPDestroy::getPriority() const
2783 {
2784     return PostPlatformPriority;
2785 }
2786
2787 void LinuxHandleLWPDestroy::getEventTypesHandled(std::vector<EventType> &etypes)
2788 {
2789     etypes.push_back(EventType(EventType::Pre, EventType::LWPDestroy));
2790 }
2791
2792 LinuxHandleForceTerminate::LinuxHandleForceTerminate() :
2793    Handler("Linux Force Termination") {};
2794
2795 LinuxHandleForceTerminate::~LinuxHandleForceTerminate() {}
2796
2797 Handler::handler_ret_t LinuxHandleForceTerminate::handleEvent(Event::ptr ev) {
2798    int_process *proc = ev->getProcess()->llproc();
2799
2800    for (int_threadPool::iterator iter = proc->threadPool()->begin(); 
2801         iter != proc->threadPool()->end(); ++iter) {
2802 #if defined(os_linux)
2803       do_ptrace((pt_req) PTRACE_DETACH, (*iter)->getLWP(), NULL, NULL);
2804 #endif
2805    }
2806    return ret_success;
2807 }
2808
2809 int LinuxHandleForceTerminate::getPriority() const
2810 {
2811    return PostPlatformPriority;
2812 }
2813
2814 void LinuxHandleForceTerminate::getEventTypesHandled(std::vector<EventType> &etypes)
2815 {
2816    etypes.push_back(EventType(EventType::Post, EventType::ForceTerminate));
2817 }
2818
2819 HandlerPool *linux_createDefaultHandlerPool(HandlerPool *hpool)
2820 {
2821    static bool initialized = false;
2822    static LinuxHandleNewThr *lbootstrap = NULL;
2823    static LinuxHandleForceTerminate *lterm = NULL;
2824    if (!initialized) {
2825       lbootstrap = new LinuxHandleNewThr();
2826       lterm = new LinuxHandleForceTerminate();
2827       initialized = true;
2828    }
2829    hpool->addHandler(lbootstrap);
2830    hpool->addHandler(lterm);
2831    thread_db_process::addThreadDBHandlers(hpool);
2832    sysv_process::addSysVHandlers(hpool);
2833    return hpool;
2834 }
2835
2836 HandlerPool *plat_createDefaultHandlerPool(HandlerPool *hpool)
2837 {
2838    return linux_createDefaultHandlerPool(hpool);
2839 }
2840
2841 bool ProcessPool::LWPIDsAreUnique()
2842 {
2843    return true;
2844 }
2845
2846 LinuxPtrace *LinuxPtrace::linuxptrace = NULL;
2847
2848 long do_ptrace(pt_req request, pid_t pid, void *addr, void *data)
2849 {
2850    return LinuxPtrace::getPtracer()->ptrace_int(request, pid, addr, data);
2851 }
2852
2853 LinuxPtrace *LinuxPtrace::getPtracer()
2854 {
2855    if (!linuxptrace) {
2856       linuxptrace = new LinuxPtrace();
2857       assert(linuxptrace);
2858       linuxptrace->start();
2859    }
2860    return linuxptrace;
2861 }
2862
2863
2864 LinuxPtrace::LinuxPtrace() :
2865    ptrace_request(unknown),
2866    request((pt_req) 0),
2867    pid(0),
2868    addr(NULL),
2869    data(NULL),
2870    proc(NULL),
2871    remote_addr(0),
2872    size(0),
2873    ret(0),
2874    bret(false),
2875    err(0)
2876 {
2877 }
2878
2879 LinuxPtrace::~LinuxPtrace()
2880 {
2881 }
2882
2883 static void start_ptrace(void *lp)
2884 {
2885    LinuxPtrace *linuxptrace = (LinuxPtrace *) (lp);
2886    linuxptrace->main();
2887 }
2888
2889 void LinuxPtrace::start()
2890 {
2891    init.lock();
2892    thrd.spawn(start_ptrace, this);
2893    init.wait();
2894    init.unlock();
2895 }
2896
2897 void LinuxPtrace::main()
2898 {
2899    init.lock();
2900    cond.lock();
2901    init.signal();
2902    init.unlock();
2903    for (;;) {
2904       cond.wait();
2905       ret_lock.lock();
2906       switch(ptrace_request) {
2907          case create_req:
2908             bret = proc->plat_create_int();
2909             break;
2910          case ptrace_req:
2911             ret = ptrace(request, pid, addr, data);
2912             break;
2913          case ptrace_bulkread:
2914             bret = PtraceBulkRead(remote_addr, size, data, pid);
2915             break;
2916          case ptrace_bulkwrite:
2917             bret = PtraceBulkWrite(remote_addr, size, data, pid);
2918             break;            
2919          case unknown:
2920             assert(0);
2921       }
2922       err = errno;
2923       ret_lock.signal();
2924       ret_lock.unlock();
2925    }
2926 }
2927
2928 void LinuxPtrace::start_request()
2929 {
2930    request_lock.lock();
2931    cond.lock();
2932    ret_lock.lock();
2933 }
2934
2935 void LinuxPtrace::waitfor_ret()
2936 {
2937    cond.signal();
2938    cond.unlock();
2939    ret_lock.wait();   
2940 }
2941
2942 void LinuxPtrace::end_request()
2943 {
2944    ret_lock.unlock();
2945    request_lock.unlock();
2946 }
2947
2948 long LinuxPtrace::ptrace_int(pt_req request_, pid_t pid_, void *addr_, void *data_)
2949 {
2950    start_request();
2951
2952    ptrace_request = ptrace_req;
2953    request = request_;
2954    pid = pid_;
2955    addr = addr_;
2956    data = data_;
2957
2958    waitfor_ret();
2959    
2960    long myret = ret;
2961    int my_errno = err;
2962
2963    end_request();
2964
2965    errno = my_errno;
2966    return myret;
2967 }
2968
2969 bool LinuxPtrace::plat_create(linux_process *p)
2970 {
2971    start_request();
2972    ptrace_request = create_req;
2973    proc = p;
2974    waitfor_ret();
2975    bool result = bret;
2976    end_request();
2977    return result;
2978 }
2979
2980 bool LinuxPtrace::ptrace_read(Dyninst::Address inTrace, unsigned size_, 
2981                               void *inSelf, int pid_)
2982 {
2983    start_request();
2984    ptrace_request = ptrace_bulkread;
2985    remote_addr = inTrace;
2986    data = inSelf;
2987    pid = pid_;
2988    size = size_;
2989    waitfor_ret();
2990    bool result = bret;
2991    end_request();
2992    return result;
2993 }
2994
2995 bool LinuxPtrace::ptrace_write(Dyninst::Address inTrace, unsigned size_, 
2996                                const void *inSelf, int pid_)
2997 {
2998    start_request();
2999    ptrace_request = ptrace_bulkwrite;
3000    remote_addr = inTrace;
3001    data = const_cast<void *>(inSelf);
3002    pid = pid_;
3003    size = size_;
3004    waitfor_ret();
3005    bool result = bret;
3006    end_request();
3007    return result;
3008 }
3009
3010
3011 void linux_process::plat_adjustSyncType(Event::ptr ev, bool gen)
3012 {
3013    if (gen) return;
3014
3015    if (ev->getEventType().code() != EventType::LWPDestroy ||
3016        ev->getEventType().time() != EventType::Pre) 
3017       return;
3018
3019    int_thread *thrd = ev->getThread()->llthrd();
3020    if (thrd->getGeneratorState().getState() != int_thread::running)
3021       return;
3022
3023    // So we have a pre-LWP destroy and a running generator; this means
3024    // that someone continued the thread during decode and it is now
3025    // gone. So set the event to async and set the generator state to
3026    // exited.
3027
3028    pthrd_printf("plat_adjustSyncType: thread %d raced with exit, setting event to async\n",
3029                 thrd->getLWP());
3030
3031    //thrd->getGeneratorState().setState(int_thread::exited);
3032    ev->setSyncType(Event::async);
3033    //thrd->getHandlerState().setState(int_thread::exited);
3034 }
3035
3036