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