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