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