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