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