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