First pass at thread_db integration for FreeBSD.
[dyninst.git] / proccontrol / src / freebsd.C
1 /*
2  * Copyright (c) 1996-2009 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as "Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * By your use of Paradyn, you understand and agree that we (or any
12  * other person or entity with proprietary rights in Paradyn) are
13  * under no obligation to provide either maintenance services,
14  * update services, notices of latent defects, or correction of
15  * defects for Paradyn.
16  * 
17  * This library is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU Lesser General Public
19  * License as published by the Free Software Foundation; either
20  * version 2.1 of the License, or (at your option) any later version.
21  * 
22  * This library is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
25  * Lesser General Public License for more details.
26  * 
27  * You should have received a copy of the GNU Lesser General Public
28  * License along with this library; if not, write to the Free Software
29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30  */
31
32 #include "dynutil/h/dyn_regs.h"
33 #include "dynutil/h/dyntypes.h"
34 #include "proccontrol/h/PCErrors.h"
35 #include "proccontrol/h/Generator.h"
36 #include "proccontrol/h/Event.h"
37 #include "proccontrol/h/Handler.h"
38 #include "proccontrol/src/procpool.h"
39 #include "proccontrol/src/irpc.h"
40 #include "proccontrol/src/snippets.h"
41 #include "proccontrol/src/freebsd.h"
42 #include "proccontrol/src/int_handler.h"
43 #include "common/h/freebsdKludges.h"
44
45 // System includes
46 #include <sys/syscall.h>
47 #include <sys/types.h>
48 #include <sys/wait.h>
49 #include <sys/time.h>
50 #include <sys/resource.h>
51 #include <signal.h>
52 #include <sys/ptrace.h>
53 #include <machine/reg.h>
54 #include <sched.h>
55
56 #if defined(arch_x86) || defined(arch_x86_64)
57 #include <machine/psl.h>
58 #endif
59
60 #include <cassert>
61 #include <cerrno>
62
63 #include <map>
64 using std::make_pair;
65
66 using namespace Dyninst;
67 using namespace ProcControlAPI;
68
69 #define NA_FREEBSD "This function is not implemented on FreeBSD"
70
71 Generator *Generator::getDefaultGenerator() {
72     static GeneratorFreeBSD *gen = NULL;
73     if( NULL == gen ) {
74         gen = new GeneratorFreeBSD();
75         assert(gen);
76         gen->launch();
77     }
78     return static_cast<Generator *>(gen);
79 }
80
81 GeneratorFreeBSD::GeneratorFreeBSD() :
82     GeneratorMT(std::string("FreeBSD Generator"))
83 {
84     decoders.insert(new DecoderFreeBSD());
85 }
86
87 GeneratorFreeBSD::~GeneratorFreeBSD()
88 {
89 }
90
91 bool GeneratorFreeBSD::initialize() {
92     return true;
93 }
94
95 bool GeneratorFreeBSD::canFastHandle() {
96     return false;
97 }
98
99 ArchEvent *GeneratorFreeBSD::getEvent(bool block) {
100     int status, options;
101
102     //Block (or not block) in waitpid to receive a OS event
103     options = block ? 0 : WNOHANG;
104     pthrd_printf("%s in waitpid\n", block ? "blocking" : "polling");
105     int pid = waitpid(-1, &status, options);
106     lwpid_t lwp = NULL_LWP;
107
108     ArchEventFreeBSD *newevent = NULL;
109     if (pid == -1) {
110         int errsv = errno;
111         if (errsv == EINTR) {
112             pthrd_printf("waitpid interrupted\n");
113             newevent = new ArchEventFreeBSD(true);
114             return newevent;
115         }
116         perr_printf("Error. waitpid recieved error %s\n", strerror(errsv));
117         newevent = new ArchEventFreeBSD(errsv);
118         return newevent;
119     }
120
121     if (dyninst_debug_proccontrol)
122     {
123         pthrd_printf("Waitpid return status %x for pid %d:\n", status, pid);
124         if (WIFEXITED(status))
125             pthrd_printf("Exited with %d\n", WEXITSTATUS(status));
126         else if (WIFSIGNALED(status))
127             pthrd_printf("Exited with signal %d\n", WTERMSIG(status));
128         else if (WIFSTOPPED(status))
129             pthrd_printf("Stopped with signal %d\n", WSTOPSIG(status));
130 #if defined(WIFCONTINUED)
131         else if (WIFCONTINUED(status))
132             perr_printf("Continued with signal SIGCONT (Unexpected)\n");
133 #endif
134         else
135             pthrd_printf("Unable to interpret waitpid return.\n");
136     }
137
138     // On FreeBSD, we need to get information about the thread that caused the
139     // stop via ptrace -- try for all cases; the ptrace call will fail for some
140     struct ptrace_lwpinfo lwpInfo;
141     if( 0 == ptrace(PT_LWPINFO, pid, (caddr_t)&lwpInfo, sizeof(struct ptrace_lwpinfo)) ) {
142         lwp = lwpInfo.pl_lwpid;
143     }else{
144         int errsv = errno;
145         pthrd_printf("Failed to retrieve lwp for pid %d: %s\n", pid, strerror(errsv));
146
147         // It's an error for a stopped or signaled process
148         if( WIFSTOPPED(status) || WIFSIGNALED(status) ) {
149             newevent = new ArchEventFreeBSD(errsv);
150             return newevent;
151         }
152     }
153
154     newevent = new ArchEventFreeBSD(pid, lwp, status);
155     return newevent;
156 }
157
158 ArchEventFreeBSD::ArchEventFreeBSD(bool inter_) :
159     status(0),
160     pid(NULL_PID),
161     lwp(NULL_LWP),
162     interrupted(inter_),
163     error(0)
164 {
165 }
166
167 ArchEventFreeBSD::ArchEventFreeBSD(pid_t p, lwpid_t l, int s) :
168     status(s),
169     pid(p),
170     lwp(l),
171     interrupted(false),
172     error(0)
173 {
174 }
175
176 ArchEventFreeBSD::ArchEventFreeBSD(int e) :
177     status(0),
178     pid(NULL_PID),
179     lwp(NULL_LWP),
180     interrupted(false),
181     error(e)
182 {
183 }
184       
185 ArchEventFreeBSD::~ArchEventFreeBSD()
186 {
187 }
188
189 DecoderFreeBSD::DecoderFreeBSD() 
190 {
191 }
192
193 DecoderFreeBSD::~DecoderFreeBSD()
194 {
195 }
196
197 unsigned DecoderFreeBSD::getPriority() const
198 {
199     return Decoder::default_priority;
200 }
201
202 Dyninst::Address DecoderFreeBSD::adjustTrapAddr(Dyninst::Address addr, Dyninst::Architecture arch)
203 {
204     if( arch == Dyninst::Arch_x86 || arch == Dyninst::Arch_x86_64 ) {
205         return addr - 1;
206     }
207
208     return addr;
209 }
210
211 bool DecoderFreeBSD::decode(ArchEvent *ae, std::vector<Event::ptr> &events) {
212     ArchEventFreeBSD *archevent = static_cast<ArchEventFreeBSD *>(ae);
213
214     int_process *proc = NULL;
215     int_thread *thread = NULL;
216     freebsd_process *lproc = NULL;
217     freebsd_thread *lthread = NULL;
218
219     proc = ProcPool()->findProcByPid(archevent->pid);
220
221     /* ignore any events we get for processes we don't know anything about.
222      * This occurs when for a double exit event as described below near
223      * WIFEXITED
224      */
225     if( !proc ) {
226         pthrd_printf("Ignoring ArchEvent for unknown process with PID %d\n",
227                 archevent->pid);
228         return true;
229     }
230
231     lproc = static_cast<freebsd_process *>(proc);
232
233     thread = ProcPool()->findThread(archevent->lwp);
234
235     // If the ArchEvent did not set the LWP, assign the event to the initial thread
236     if( !thread ) {
237         thread = proc->threadPool()->initialThread();
238     }
239     lthread = static_cast<freebsd_thread *>(thread);
240
241     Event::ptr event;
242
243     pthrd_printf("Decoding event for %d/%d\n", proc ? proc->getPid() : -1,
244             thread ? thread->getLWP() : -1);
245
246     const int status = archevent->status;
247     bool result = false;
248     if( WIFSTOPPED(status) ) {
249         const int stopsig = WSTOPSIG(status);
250
251         pthrd_printf("Decoded to signal %s\n", strsignal(stopsig));
252         switch( stopsig ) {
253             case SIGSTOP:
254                 if( lthread->hasPendingStop() ) {
255                     pthrd_printf("Received pending SIGSTOP on %d/%d\n",
256                             thread->llproc()->getPid(), thread->getLWP());
257                     event = Event::ptr(new EventStop());
258                     break;
259                 }
260                 // Relying on fall through for bootstrap
261             case SIGTRAP: {
262                 if( proc->getState() == int_process::neonatal_intermediate) {
263                     pthrd_printf("Decoded event to bootstrap on %d/%d\n",
264                             proc->getPid(), thread->getLWP());
265                     event = Event::ptr(new EventBootstrap());
266                     break;
267                 }
268
269                 Dyninst::MachRegisterVal addr;
270                 result = thread->getRegister(MachRegister::getPC(proc->getTargetArch()), addr);
271                 if( !result ) {
272                     perr_printf("Failed to read PC address upon SIGTRAP\n");
273                     return false;
274                 }
275
276                 Dyninst::Address adjusted_addr = adjustTrapAddr(addr, proc->getTargetArch());
277
278                 // Check if it is a RPC
279                 if (rpcMgr()->isRPCTrap(thread, adjusted_addr)) {
280                    pthrd_printf("Decoded event to rpc completion on %d/%d at %lx\n",
281                                 proc->getPid(), thread->getLWP(), adjusted_addr);
282                    event = Event::ptr(new EventRPC(thread->runningRPC()->getWrapperForDecode()));
283                    break;
284                 }
285
286                 // Check if it is a breakpoint
287                 installed_breakpoint *ibp = proc->getBreakpoint(adjusted_addr);
288                 if( ibp && ibp != thread->isClearingBreakpoint() ) {
289                     pthrd_printf("Decoded breakpoint on %d/%d at %lx\n", proc->getPid(),
290                             thread->getLWP(), adjusted_addr);
291                     event = Event::ptr(new EventBreakpoint(adjusted_addr, ibp));
292                     event->setSyncType(Event::sync_thread);
293
294                     if( adjusted_addr == lproc->getLibBreakpointAddr() ) {
295                         pthrd_printf("Breakpoint is library load/unload\n");
296                         Event::ptr lib_event = Event::ptr(new EventLibrary());
297                         lib_event->setThread(thread->thread());
298                         lib_event->setProcess(proc->proc());
299                         event->addSubservientEvent(lib_event);
300                     }else{
301                         // Check for thread events
302                         vector<Event::ptr> threadEvents;
303                         if( lproc->getEventsAtAddr(adjusted_addr, lthread, threadEvents) ) {
304                             assert(thread->thread());
305                             assert(proc->proc());
306
307                             vector<Event::ptr>::iterator threadEventIter;
308                             for(threadEventIter = threadEvents.begin(); threadEventIter != threadEvents.end();
309                                     ++threadEventIter)
310                             {
311                                 // An event is created for the initial thread, but this thread is already
312                                 // created during bootstrap. Ignore any create events for threads that
313                                 // are already created.
314                                 if( (*threadEventIter)->getEventType().code() == EventType::ThreadCreate ) {
315                                     Dyninst::LWP createdLWP = (*threadEventIter)->getEventNewThread()->getLWP();
316                                     int_thread * newThread = ProcPool()->findThread(createdLWP);
317                                     if( NULL != newThread ) {
318                                         freebsd_thread *newlThread = static_cast<freebsd_thread *>(newThread);
319                                         pthrd_printf("Thread already created for LWP %d\n", createdLWP);
320
321                                         // Still need to enable events for it -- this can't be done during
322                                         // bootstrap because the thread_db library isn't guaranteed to 
323                                         // be initialized at this point
324                                         newlThread->setEventReporting(true);
325                                         continue;
326                                     }
327                                 }
328
329                                 (*threadEventIter)->setThread(thread->thread());
330                                 (*threadEventIter)->setProcess(proc->proc());
331                                 event->addSubservientEvent(*threadEventIter);
332                             }
333                         }
334                     }
335                     break;
336                 }
337
338                 if( thread->singleStep() ) {
339                     ibp = thread->isClearingBreakpoint();
340                     if( ibp ) {
341                         pthrd_printf("Decoded event to breakpoint cleanup\n");
342                         event = Event::ptr(new EventBreakpointClear(ibp));
343                         break;
344                     }else{
345                         pthrd_printf("Decoded event to single step on %d/%d\n",
346                                 proc->getPid(), thread->getLWP());
347                         event = Event::ptr(new EventSingleStep());
348                         break;
349                     }
350                 }else{
351                     // TODO for now, just assume that a call to exec happened
352                     // In the future, if we need to trace syscalls, we will
353                     // need to differentiate between different syscalls
354                     //
355                     // breadcrumb: 
356                     // truss(1) does system call identification after a SIGTRAP
357                     pthrd_printf("Decoded event to exec on %d/%d\n",
358                             proc->getPid(), thread->getLWP());
359                     event = Event::ptr(new EventExec(EventType::Post));
360                 }
361                 break;
362             }
363             default:
364                 pthrd_printf("Decoded event to signal %d on %d/%d\n",
365                         stopsig, proc->getPid(), thread->getLWP());
366 #if 1
367                 //Debugging code
368                 if (stopsig == SIGSEGV) {
369                    Dyninst::MachRegisterVal addr;
370                    result = thread->getRegister(MachRegister::getPC(proc->getTargetArch()), addr);
371                    if (!result) {
372                       fprintf(stderr, "Failed to read PC address upon crash\n");
373                    }
374                    fprintf(stderr, "Got crash at %lx\n", addr);
375
376                    size_t readSize = 10;
377                    void *local = malloc(readSize);
378                    if( !PtraceBulkRead(addr, readSize, local, proc->getPid()) ) {
379                        fprintf(stderr, "Failed to read memory at %lx\n", addr);
380                    }else{
381                        unsigned char *localBytes = (unsigned char *)local;
382                        fprintf(stderr, "%lx: ", addr);
383                        for(unsigned i = 0; i < readSize; ++i) {
384                            fprintf(stderr, "%x ", localBytes[i]);
385                        }
386                        fprintf(stderr, "\n");
387                    }
388
389                    while (1) sleep(1);
390                 }
391 #endif
392                 event = Event::ptr(new EventSignal(stopsig));
393                 break;
394         }
395     }
396     else if (WIFEXITED(status) || WIFSIGNALED(status)) {
397         if( WIFEXITED(status) ) {
398             int exitcode = WEXITSTATUS(status);
399             /*
400              * On FreeBSD, an exit of a traced process is reported to both its original
401              * parent and the tracing process. When the traced process is created by a
402              * ProcControlAPI process, ProcControlAPI will receive two copies of the exit
403              * event. The second event should be ignored.
404              */
405             if( int_thread::exited == thread->getGeneratorState() ) {
406                 pthrd_printf("Decoded duplicate exit event of process %d/%d with code %d\n",
407                         proc->getPid(), thread->getLWP(), exitcode);
408                 return true;
409             }
410
411             pthrd_printf("Decoded event to exit of process %d/%d with code %d\n",
412                     proc->getPid(), thread->getLWP(), exitcode);
413             event = Event::ptr(new EventExit(EventType::Post, exitcode));
414         }else{
415             int termsig = WTERMSIG(status);
416             pthrd_printf("Decoded event to crash of %d/%d with signal %d\n",
417                     proc->getPid(), thread->getLWP(), termsig);
418             event = Event::ptr(new EventCrash(termsig));
419         }
420         int_threadPool::iterator i = proc->threadPool()->begin();
421         for(; i != proc->threadPool()->end(); ++i) {
422             (*i)->setGeneratorState(int_thread::exited);
423         }
424     }
425
426     assert(event);
427     assert(proc->proc());
428     assert(thread->thread());
429
430     // Most events on FreeBSD are sync_process - all signals stop the entire
431     // process
432     if( event && event->getSyncType() == Event::unset)
433         event->setSyncType(Event::sync_process);
434
435     event->setThread(thread->thread());
436     event->setProcess(proc->proc());
437     events.push_back(event);
438
439     delete archevent;
440
441     return true;
442 }
443
444 int_process *int_process::createProcess(Dyninst::PID pid_, std::string exec) {
445     std::vector<std::string> args;
446     freebsd_process *newproc = new freebsd_process(pid_, exec, args);
447     assert(newproc);
448
449     return static_cast<int_process *>(newproc);
450 }
451
452 int_process *int_process::createProcess(std::string exec, std::vector<std::string> args) {
453     freebsd_process *newproc = new freebsd_process(0, exec, args);
454     assert(newproc);
455     return static_cast<int_process *>(newproc);
456 }
457
458 int_process *int_process::createProcess(Dyninst::PID pid_, int_process *parent) {
459     freebsd_process *newproc = new freebsd_process(pid_, parent);
460     assert(newproc);
461     return static_cast<int_process *>(newproc);
462 }
463
464 int_thread *int_thread::createThreadPlat(int_process *proc, Dyninst::THR_ID thr_id,
465         Dyninst::LWP lwp_id, bool initial_thrd)
466 {
467     if( initial_thrd ) {
468         freebsd_process *tmpProc = static_cast<freebsd_process *>(proc);
469         
470         vector<Dyninst::LWP> lwps;
471         tmpProc->getThreadLWPs(lwps);
472         assert( lwps.size() == 1 );
473
474         lwp_id = lwps.back();
475     }
476     freebsd_thread *lthrd = new freebsd_thread(proc, thr_id, lwp_id);
477     assert(lthrd);
478     return static_cast<int_thread *>(lthrd);
479 }
480
481 HandlerPool *plat_createDefaultHandlerPool(HandlerPool *hpool) {
482     // TODO add special stop handler
483     thread_db_process::addThreadDBHandlers(hpool);
484     return hpool;
485 }
486
487 bool ProcessPool::LWPIDsAreUnique() {
488     return true;
489 }
490
491 freebsd_process::freebsd_process(Dyninst::PID p, std::string e, std::vector<std::string> a)
492     : thread_db_process(p, e, a)
493 {
494 }
495
496 freebsd_process::freebsd_process(Dyninst::PID pid_, int_process *p) 
497     : thread_db_process(pid_, p)
498 {
499 }
500
501 freebsd_process::~freebsd_process() 
502 {
503 }
504
505 bool freebsd_process::plat_create() {
506     pid = fork();
507     if( -1 == pid ) {
508         int errnum = errno;
509         pthrd_printf("Could not fork new process for %s: %s\n",
510                 executable.c_str(), strerror(errnum));
511         setLastError(err_internal, "Unable to fork new process");
512         return false;
513     }
514
515     if( !pid ) {
516         // Child
517         if( 0 != ptrace(PT_TRACE_ME, 0, 0, 0) ) {
518             perr_printf("Faild to execute a PT_TRACE_ME.\n");
519             setLastError(err_internal, "Unable to debug trace new process");
520             exit(-1);
521         }
522
523         plat_execv(); // Never returns
524
525         exit(-1);
526     }
527
528     return true;
529 }
530
531 bool freebsd_process::plat_attach() {
532     pthrd_printf("Attaching to pid %d\n", pid);
533     if( 0 != ptrace(PT_ATTACH, pid, (caddr_t)1, 0) ) {
534         int errnum = errno;
535         pthrd_printf("Unable to attach to process %d: %s\n", pid, strerror(errnum));
536         if( EPERM == errnum ) {
537             setLastError(err_prem, "Do not have correct permissions to attach to pid");
538         }else if( ESRCH == errnum ) {
539             setLastError(err_noproc, "The specified process was not found");
540         }else {
541             setLastError(err_internal, "Unable to attach to the specified process");
542         }
543         return false;
544     }
545     return true;
546 }
547
548 bool freebsd_process::plat_forked() {
549     // TODO
550     assert(!NA_FREEBSD);
551     return false;
552 }
553
554 bool freebsd_process::post_forked() {
555     // TODO
556     assert(!NA_FREEBSD);
557     return false;
558 }
559
560 bool freebsd_process::plat_execed() { 
561     bool result = sysv_process::plat_execed();
562     if( !result ) return false;
563
564     char *pathname = sysctl_getExecPathname(getPid());
565     if( NULL == pathname ) {
566         perr_printf("Failed to retrieve executable pathname");
567         setLastError(err_internal, "Failed to retrieve executable pathname");
568         return false;
569     }
570
571     executable = pathname;
572     free(pathname);
573     return true;
574 }
575
576 bool freebsd_process::plat_detach() {
577     pthrd_printf("PT_DETACH on %d\n", getPid());
578     if( 0 != ptrace(PT_DETACH, getPid(), (caddr_t)1, 0) ) {
579         perr_printf("Failed to PT_DETACH on %d\n", getPid());
580         setLastError(err_internal, "PT_DETACH operation failed\n");
581     }
582     return true;
583 }
584
585 bool freebsd_process::plat_terminate(bool &needs_sync) {
586     pthrd_printf("Terminating process %d\n", getPid());
587     if( 0 != ptrace(PT_KILL, getPid(), (caddr_t)1, 0) ) {
588         perr_printf("Failed to PT_KILL process %d\n", getPid());
589         setLastError(err_internal, "PT_KILL operation failed\n");
590         return false;
591     }
592
593     needs_sync = true;
594     return true;
595 }
596
597 bool freebsd_process::plat_readMem(int_thread *thr, void *local, 
598                          Dyninst::Address remote, size_t size) 
599 {
600     return PtraceBulkRead(remote, size, local, thr->llproc()->getPid());
601 }
602
603 bool freebsd_process::plat_readProcMem(void *local, 
604         Dyninst::Address remote, size_t size)
605 {
606     return PtraceBulkRead(remote, size, local, getPid());
607 }
608
609 bool freebsd_process::plat_writeMem(int_thread *thr, void *local, 
610                           Dyninst::Address remote, size_t size) 
611 {
612     return PtraceBulkWrite(remote, size, local, thr->llproc()->getPid());
613 }
614
615 bool freebsd_process::plat_writeProcMem(void *local, 
616                           Dyninst::Address remote, size_t size) 
617 {
618     return PtraceBulkWrite(remote, size, local, getPid());
619 }
620
621 bool freebsd_process::needIndividualThreadAttach() {
622     return false;
623 }
624
625 bool freebsd_process::getThreadLWPs(std::vector<Dyninst::LWP> &lwps) {
626     return sysctl_findProcLWPs(getPid(), lwps);
627 }
628
629 Dyninst::Architecture freebsd_process::getTargetArch() {
630     if( Dyninst::Arch_none != arch ) {
631         return arch;
632     }
633     int addr_width = sysctl_computeAddrWidth(getPid());
634
635 #if defined(arch_x86) || defined(arch_x86_64)
636     assert(addr_width == 4 || addr_width == 8);
637     arch = (addr_width == 4) ? Dyninst::Arch_x86 : Dyninst::Arch_x86_64;
638 #elif defined(arch_power)
639     assert(addr_width == 4 || addr_width == 8);
640     arch = (addr_width == 4) ? Dyninst::Arch_ppc32 : Dyninst::Arch_ppc64;
641 #else
642     assert(!"Unknown architecture");
643 #endif
644     return arch;
645 }
646
647 bool freebsd_process::independentLWPControl() {
648     // TODO for now, this will probably need to change to a hybrid
649     return true;
650 }
651
652 bool freebsd_process::plat_getLWPInfo(lwpid_t lwp, void *lwpInfo) {
653     if( 0 != ptrace(PT_LWPINFO, lwp, (caddr_t)lwpInfo, sizeof(struct ptrace_lwpinfo)) ) {
654         perr_printf("Failed to get thread info for lwp %d: %s\n",
655                 lwp, strerror(errno));
656         setLastError(err_internal, "Failed to get thread info");
657         return false;
658     }
659
660     return true;
661 }
662
663 bool freebsd_process::plat_contThread(lwpid_t lwp) {
664     if( 0 != ptrace(PT_RESUME, lwp, (caddr_t)1, 0) ) {
665         perr_printf("Failed to resume lwp %d: %s\n",
666                 lwp, strerror(errno));
667         setLastError(err_internal, "Failed to resume lwp");
668         return false;
669     }
670
671     return true;
672 }
673
674 bool freebsd_process::plat_stopThread(lwpid_t lwp) {
675     if( 0 != ptrace(PT_SUSPEND, lwp, (caddr_t)1, 0) ) {
676         perr_printf("Failed to suspend lwp %d: %s\n",
677                 lwp, strerror(errno));
678         setLastError(err_internal, "Failed to suspend lwp");
679         return false;
680     }
681
682     return true;
683 }
684
685 freebsd_thread::freebsd_thread(int_process *p, Dyninst::THR_ID t, Dyninst::LWP l)
686     : thread_db_thread(p, t, l)
687 {
688 }
689
690 freebsd_thread::~freebsd_thread() 
691 {
692 }
693
694 bool freebsd_thread::plat_cont() {
695     // TODO the whole process is continued
696     //
697     // On FreeBSD, individual threads are controlled by stopping the whole
698     // process and then suspending or resuming individual threads before
699     // continuing the process.
700     //
701
702     pthrd_printf("Continuing thread %d\n", lwp);
703
704     int result;
705     if (singleStep()) {
706         pthrd_printf("Calling PT_STEP on %d with signal %d\n", 
707                 lwp, continueSig_);
708         result = ptrace(PT_STEP, proc_->getPid(), (caddr_t)1, continueSig_);
709     } else {
710         pthrd_printf("Calling PT_CONTINUE on %d with signal %d\n", 
711                 proc_->getPid(), continueSig_);
712         result = ptrace(PT_CONTINUE, proc_->getPid(), (caddr_t)1, continueSig_);
713     }
714
715     if (0 != result) {
716         int error = errno;
717         perr_printf("low-level continue failed: %s\n", strerror(error));
718         setLastError(err_internal, "Low-level continue failed");
719         return false;
720     }
721
722     //
723     // XXX
724     //
725     // This attempts to get around the bug documented in FreeBSD problem
726     // report kern/142757 -- if we yield to the scheduler, we may avoid
727     // the race condition described in this bug report.
728     //
729     // Specifically, the race condition results from the following sequence
730     // of events, where P = parent process, C = child process:
731     //
732     // P-SIGSTOP C-STOP P-WAITPID P-CONT P-SIGSTOP C-RUN
733     // 
734     // Because the child doesn't run before the parent sends the second 
735     // stop signal, the child doesn't receive the second SIGSTOP. 
736     //
737     // A workaround for this problem would guarantee that the C-RUN event
738     // always occurs before the second P-SIGSTOP. Here, the sched_yield
739     // attempts to ensure this.
740     //
741     // TODO this doesn't always solve the problem
742     
743     sched_yield();
744
745     return true;
746 }
747
748 static bool t_kill(pid_t pid, long lwp, int sig) {
749     static bool has_tkill = true;
750     int result = 0;
751
752     pthrd_printf("Sending %d to %ld/%d\n", sig, lwp, pid);
753
754     if( has_tkill ) {
755         // No threads have been created yet
756         if( pid == lwp ) {
757             result = kill(pid, sig);
758         }else{
759             result = syscall(SYS_thr_kill2, pid, lwp, sig);
760             if( 0 != result && ENOSYS == errno ) {
761                 pthrd_printf("Using kill instead of tkill on this system\n");
762                 has_tkill = false;
763             }
764         }
765     }
766
767     if( !has_tkill ) {
768         result = kill(pid, sig);
769     }
770
771     return (result == 0);
772 }
773
774 bool freebsd_thread::plat_stop() {
775     assert(pending_stop);
776
777     Dyninst::PID pid = proc_->getPid();
778     if( !t_kill(pid, lwp, SIGSTOP) ) {
779         int errnum = errno;
780         if( ESRCH == errnum ) {
781             pthrd_printf("t_kill failed for %d/%d, thread/process doesn't exist\n", lwp, pid);
782             setLastError(err_noproc, "Thread no longer exists");
783             return false;
784         }
785         pthrd_printf("t_kill failed on %d/%d: %s\n", lwp, pid, strerror(errnum));
786         setLastError(err_internal, "Could not send signal to process while stopping");
787         return false;
788     }
789
790     return true;
791 }
792
793 bool freebsd_thread::attach() {
794     // On FreeBSD, an attach is not necessary for threads
795     return true;
796 }
797
798 static dynreg_to_user_t dynreg_to_user;
799 static void init_dynreg_to_user() {
800     static volatile bool initialized = false;
801     static Mutex init_lock;
802     if( initialized ) return;
803
804     init_lock.lock();
805     if( initialized ) {
806         init_lock.unlock();
807         return;
808     }
809
810 #if defined(arch_x86_64)
811     dynreg_to_user[x86_64::r15] =   make_pair(offsetof(reg, r_r15), 8);
812     dynreg_to_user[x86_64::r14] =   make_pair(offsetof(reg, r_r14), 8);
813     dynreg_to_user[x86_64::r13] =   make_pair(offsetof(reg, r_r13), 8);
814     dynreg_to_user[x86_64::r12] =   make_pair(offsetof(reg, r_r12), 8);
815     dynreg_to_user[x86_64::r11] =   make_pair(offsetof(reg, r_r11), 8);
816     dynreg_to_user[x86_64::r10] =   make_pair(offsetof(reg, r_r10), 8);
817     dynreg_to_user[x86_64::r9] =    make_pair(offsetof(reg, r_r9), 8);
818     dynreg_to_user[x86_64::r8] =    make_pair(offsetof(reg, r_r8), 8);
819     dynreg_to_user[x86_64::rdi] =   make_pair(offsetof(reg, r_rdi), 8);
820     dynreg_to_user[x86_64::rsi] =   make_pair(offsetof(reg, r_rsi), 8);
821     dynreg_to_user[x86_64::rbp] =   make_pair(offsetof(reg, r_rbp), 8);
822     dynreg_to_user[x86_64::rbx] =   make_pair(offsetof(reg, r_rbx), 8);
823     dynreg_to_user[x86_64::rdx] =   make_pair(offsetof(reg, r_rdx), 8);
824     dynreg_to_user[x86_64::rcx] =   make_pair(offsetof(reg, r_rcx), 8);
825     dynreg_to_user[x86_64::rax] =   make_pair(offsetof(reg, r_rax), 8);
826     dynreg_to_user[x86_64::rip] =   make_pair(offsetof(reg, r_rip), 8);
827     dynreg_to_user[x86_64::rsp] =   make_pair(offsetof(reg, r_rsp), 8);
828     dynreg_to_user[x86_64::flags] = make_pair(offsetof(reg, r_rflags), 8);
829     dynreg_to_user[x86_64::cs] =    make_pair(offsetof(reg, r_cs), 8);
830     dynreg_to_user[x86_64::ss] =    make_pair(offsetof(reg, r_ss), 8);
831
832     // x86 registers -- it appears that not all the segment registers are available
833     dynreg_to_user[x86::edi] = make_pair(offsetof(reg, r_rdi), 4);
834     dynreg_to_user[x86::esi] = make_pair(offsetof(reg, r_rsi), 4);
835     dynreg_to_user[x86::ebp] = make_pair(offsetof(reg, r_rbp), 4);
836     dynreg_to_user[x86::ebx] = make_pair(offsetof(reg, r_rbx), 4);
837     dynreg_to_user[x86::edx] = make_pair(offsetof(reg, r_rdx), 4);
838     dynreg_to_user[x86::ecx] = make_pair(offsetof(reg, r_rcx), 4);
839     dynreg_to_user[x86::eax] = make_pair(offsetof(reg, r_rax), 4);
840     dynreg_to_user[x86::eip] = make_pair(offsetof(reg, r_rip), 4);
841     dynreg_to_user[x86::flags] = make_pair(offsetof(reg, r_rflags), 4);
842     dynreg_to_user[x86::esp] = make_pair(offsetof(reg, r_rsp), 4);
843     dynreg_to_user[x86::ss] = make_pair(offsetof(reg, r_ss), 4);
844     dynreg_to_user[x86::cs] = make_pair(offsetof(reg, r_cs), 4);
845     
846 #elif defined(arch_x86)
847     dynreg_to_user[x86::fs] = make_pair(offsetof(reg, r_fs), 4);
848     dynreg_to_user[x86::es] = make_pair(offsetof(reg, r_es), 4);
849     dynreg_to_user[x86::ds] = make_pair(offsetof(reg, r_ds), 4);
850     dynreg_to_user[x86::edi] = make_pair(offsetof(reg, r_edi), 4);
851     dynreg_to_user[x86::esi] = make_pair(offsetof(reg, r_esi), 4);
852     dynreg_to_user[x86::ebp] = make_pair(offsetof(reg, r_ebp), 4);
853     dynreg_to_user[x86::ebx] = make_pair(offsetof(reg, r_ebx), 4);
854     dynreg_to_user[x86::edx] = make_pair(offsetof(reg, r_edx), 4);
855     dynreg_to_user[x86::ecx] = make_pair(offsetof(reg, r_ecx), 4);
856     dynreg_to_user[x86::eax] = make_pair(offsetof(reg, r_eax), 4);
857     dynreg_to_user[x86::eip] = make_pair(offsetof(reg, r_eip), 4);
858     dynreg_to_user[x86::cs] = make_pair(offsetof(reg, r_cs), 4);
859     dynreg_to_user[x86::flags] = make_pair(offsetof(reg, r_eflags), 4);
860     dynreg_to_user[x86::esp] = make_pair(offsetof(reg, r_esp), 4);
861     dynreg_to_user[x86::ss] = make_pair(offsetof(reg, r_ss), 4);
862     dynreg_to_user[x86::gs] = make_pair(offsetof(reg, r_gs), 4);
863 #else
864     // TODO implement this for other architectures
865     assert(!"Register conversion is not implemented for this architecture");
866 #endif
867
868     initialized = true;
869
870     init_lock.unlock();
871 }
872
873 #if 0 
874 // Debugging
875 static void dumpRegisters(struct reg *regs) {
876 #if defined(arch_x86)
877     fprintf(stderr, "r_fs = 0x%x\n", regs->r_fs);
878     fprintf(stderr, "r_es = 0x%x\n", regs->r_es);
879     fprintf(stderr, "r_ds = 0x%x\n", regs->r_ds);
880     fprintf(stderr, "r_edi = 0x%x\n", regs->r_edi);
881     fprintf(stderr, "r_esi = 0x%x\n", regs->r_esi);
882     fprintf(stderr, "r_ebp = 0x%x\n", regs->r_ebp);
883     fprintf(stderr, "r_ebx = 0x%x\n", regs->r_ebx);
884     fprintf(stderr, "r_ecx = 0x%x\n", regs->r_ecx);
885     fprintf(stderr, "r_eax = 0x%x\n", regs->r_eax);
886     fprintf(stderr, "r_eip = 0x%x\n", regs->r_eip);
887     fprintf(stderr, "r_cs = 0x%x\n", regs->r_cs);
888     fprintf(stderr, "r_eflags = 0x%x\n", regs->r_eflags);
889     fprintf(stderr, "r_esp = 0x%x\n", regs->r_esp);
890     fprintf(stderr, "r_ss = 0x%x\n", regs->r_ss);
891     fprintf(stderr, "r_gs = 0x%x\n", regs->r_gs);
892     fprintf(stderr, "r_trapno = 0x%x\n", regs->r_trapno);
893     fprintf(stderr, "r_err = 0x%x\n", regs->r_err);
894 #endif
895 }
896 #endif
897
898 bool freebsd_process::plat_individualRegAccess() {
899     return false;
900 }
901
902 string freebsd_process::getThreadLibName(const char *symName) {
903     // XXX
904     // This hack is needed because the FreeBSD implementation doesn't
905     // set the object name when looking for a symbol -- instead of
906     // searching every library for the symbol, make some educated 
907     // guesses
908     //
909     // It also assumes that the first symbols thread_db will lookup
910     // are either _libthr_debug or _libkse_debug
911     
912     if( !strcmp(symName, "_libkse_debug") ) {
913         libThreadName = "libkse.so";
914     }else if( !strcmp(symName, "_libthr_debug") || 
915             libThreadName.empty() ) 
916     {
917         libThreadName = "libthr.so";
918     }
919
920     return libThreadName;
921 }
922
923 bool freebsd_process::isSupportedThreadLib(const string &libName) {
924     if( libName.find("libthr") != string::npos ) {
925         return true;
926     }else if( libName.find("libkse") != string::npos ) {
927         return true;
928     }
929
930     return false;
931 }
932
933 bool freebsd_thread::plat_getAllRegisters(int_registerPool &regpool) {
934     struct reg registers;
935     unsigned char *regPtr = (unsigned char *)&registers;
936
937     if( 0 != ptrace(PT_GETREGS, lwp, (caddr_t)regPtr, 0) ) {
938         perr_printf("Error reading registers from LWP %d\n", lwp);
939         setLastError(err_internal, "Could not read registers from thread");
940         return false;
941     }
942
943     init_dynreg_to_user();
944
945     Dyninst::Architecture curplat = llproc()->getTargetArch();
946     regpool.regs.clear();
947
948     dynreg_to_user_t::iterator i;
949     for(i = dynreg_to_user.begin(); i != dynreg_to_user.end(); ++i ) {
950         const MachRegister reg = i->first;
951         if (reg.getArchitecture() != curplat ) continue;
952
953         MachRegisterVal val;
954         const unsigned int offset = i->second.first;
955         const unsigned int size = i->second.second;
956
957         if( size == sizeof(uint32_t) ) {
958             val = *((uint32_t *)(&regPtr[offset]));
959         }else if( size == sizeof(uint64_t) ) {
960             val = *((uint64_t *)(&regPtr[offset]));
961         }else{
962             assert(!"Unknown address width");
963         }
964         pthrd_printf("Register %s has value 0x%lx, offset 0x%x\n", reg.name(), (unsigned long)val, offset);
965         regpool.regs[reg] = val;
966     }
967
968     return true;
969 }
970
971 static bool validateRegisters(struct reg *regs, Dyninst::LWP lwp) {
972 #if defined(arch_x86)
973     struct reg old_regs;
974     if( 0 != ptrace(PT_GETREGS, lwp, (caddr_t)&old_regs, 0) ) {
975         perr_printf("Error reading registers from LWP %d\n", lwp);
976         return false;
977     }
978
979     // Sometimes the resume flag is set in the saved version of the
980     // registers and not set in the current set of registers -- 
981     // the OS doesn't allow us to change this flag, change it to the
982     // current value
983     if( (old_regs.r_eflags & PSL_RF) != (regs->r_eflags & PSL_RF) ) {
984         if( old_regs.r_eflags & PSL_RF ) regs->r_eflags |= PSL_RF;
985         else regs->r_eflags &= ~PSL_RF;
986     }
987 #endif
988     return true;
989 }
990
991 bool freebsd_thread::plat_setAllRegisters(int_registerPool &regpool) {
992     init_dynreg_to_user();
993
994     // Populate a struct reg using the registerPool
995     struct reg registers;
996     unsigned char *regPtr = (unsigned char *)&registers;
997
998     dynreg_to_user_t::iterator i;
999     unsigned num_found = 0;
1000     Dyninst::Architecture curplat = llproc()->getTargetArch();
1001
1002     for (i = dynreg_to_user.begin(); i != dynreg_to_user.end(); ++i) {
1003         const MachRegister reg = i->first;
1004         MachRegisterVal val;
1005
1006         if (reg.getArchitecture() != curplat) continue;
1007
1008         const unsigned int offset = i->second.first;
1009         const unsigned int size = i->second.second;
1010
1011         assert(offset+size <= sizeof(struct reg));
1012
1013         int_registerPool::reg_map_t::iterator j = regpool.regs.find(reg);
1014
1015         // A register was not set in the registerPool, error report after loop
1016         if( j == regpool.regs.end() ) break;
1017
1018         num_found++;
1019         val = j->second;
1020
1021         if (size == sizeof(uint32_t)) {
1022             *((uint32_t *)&regPtr[offset]) = (uint32_t) val;
1023         } else if (size == sizeof(uint64_t)) {
1024             *((uint64_t *)&regPtr[offset]) = (uint64_t) val;
1025         } else {
1026             assert(!"Unknown address width");
1027         }
1028
1029         pthrd_printf("Register %s gets value 0x%lx, offset 0x%x\n", reg.name(), (unsigned long)val, offset);
1030     }
1031
1032     if (num_found != regpool.regs.size()) {
1033         setLastError(err_badparam, "Invalid register set passed to setAllRegisters");
1034         perr_printf("Couldn't find all registers in the register set %u/%u\n", num_found,
1035                     (unsigned int) regpool.regs.size());
1036         return false;
1037     }
1038
1039     if( 0 != ptrace(PT_SETREGS, lwp, (caddr_t)&registers, 0) ) {
1040         bool success = false;
1041         if( EINVAL == errno ) {
1042             // This usually means that the flag register would change some system status bits
1043             pthrd_printf("Attempting to handle EINVAL caused by PT_SETREGS for LWP %d\n", lwp);
1044
1045             if( validateRegisters(&registers, lwp) ) {
1046                 if( !ptrace(PT_SETREGS, lwp, (caddr_t)&registers, 0) ) {
1047                     pthrd_printf("Successfully handled EINVAL caused by PT_SETREGS\n");
1048                     success = true;
1049                 }else{
1050                     perr_printf("Failed to handle EINVAL caused by PT_SETREGS\n");
1051                 }
1052             }
1053         }
1054
1055         if( !success ) {
1056             perr_printf("Error setting registers for LWP %d: %s\n", lwp, strerror(errno));
1057             setLastError(err_internal, "Could not set registers in thread");
1058             return false;
1059         }
1060     }
1061
1062     pthrd_printf("Successfully set the values of all registers for LWP %d\n", lwp);
1063
1064     return true;
1065 }
1066
1067 bool freebsd_thread::plat_getRegister(Dyninst::MachRegister, Dyninst::MachRegisterVal &) {
1068     assert(!"This platform does not have individual register access");
1069     return false;
1070 }
1071
1072 bool freebsd_thread::plat_setRegister(Dyninst::MachRegister, Dyninst::MachRegisterVal) {
1073     assert(!"This platform does not have individual register access");
1074     return false;
1075 }
1076
1077 // iRPC snippets
1078 const unsigned int x86_64_mmap_flags_position = 17;
1079 const unsigned int x86_64_mmap_size_position = 30;
1080 const unsigned int x86_64_mmap_addr_position = 40;
1081 const unsigned int x86_64_mmap_start_position = 0;
1082 const unsigned char x86_64_call_mmap[] = {
1083 0x49, 0xc7, 0xc1, 0x00, 0x00, 0x00, 0x00,       //mov    $0x0,%r9 (offset)
1084 0x49, 0xc7, 0xc0, 0xff, 0xff, 0xff, 0xff,       //mov    $0xffffffffffffffff,%r8 (fd)
1085 0x49, 0xc7, 0xc2, 0x12, 0x10, 0x00, 0x00,       //mov    $0x1012,%r10 (flags)
1086 0x48, 0xc7, 0xc2, 0x07, 0x00, 0x00, 0x00,       //mov    $0x7,%rdx (perms)
1087 0x48, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00,       //mov    $0x0000000000000000,%rsi (size)
1088 0x00, 0x00, 0x00,                               //
1089 0x48, 0xbf, 0x00, 0x00, 0x00, 0x00, 0x00,       //mov    $0x0000000000000000,%rdi (addr)
1090 0x00, 0x00, 0x00,                               //
1091 0xb8, 0xdd, 0x01, 0x00, 0x00,                   //mov    $0x1dd,%eax (SYS_mmap)
1092 0x0f, 0x05,                                     //syscall
1093 0xcc,                                           //trap
1094 0x90                                            //nop
1095 };
1096 const unsigned int x86_64_call_mmap_size = sizeof(x86_64_call_mmap);
1097
1098 const unsigned int x86_64_munmap_size_position = 2;
1099 const unsigned int x86_64_munmap_addr_position = 12;
1100 const unsigned int x86_64_munmap_start_position = 0;
1101 const unsigned char x86_64_call_munmap[] = {
1102 0x48, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00,       //mov    $0x0000000000000000,%rsi
1103 0x00, 0x00, 0x00,                               //
1104 0x48, 0xbf, 0x00, 0x00, 0x00, 0x00, 0x00,       //mov    $0x0000000000000000,%rdi
1105 0x00, 0x00, 0x00,                               //
1106 0xb8, 0x49, 0x00, 0x00, 0x00,                   //mov    $0x49,%eax
1107 0x0f, 0x05,                                     //syscall
1108 0xcc,                                           //trap
1109 0x90                                            //nop
1110 };
1111 const unsigned int x86_64_call_munmap_size = sizeof(x86_64_call_munmap);
1112
1113 const unsigned int x86_mmap_flags_position = 5;
1114 const unsigned int x86_mmap_size_position = 12;
1115 const unsigned int x86_mmap_addr_position = 17;
1116 const unsigned int x86_mmap_start_position = 0;
1117 const unsigned char x86_call_mmap[] = {
1118 0x6a, 0x00,                                     //push   $0x0 (offset)
1119 0x6a, 0xff,                                     //push   $0xffffffff (fd)
1120 0x68, 0x12, 0x10, 0x00, 0x00,                   //push   $0x1012 (flags)
1121 0x6a, 0x07,                                     //push   $0x7 (perms)
1122 0x68, 0x00, 0x00, 0x00, 0x00,                   //push   $0x0 (size)
1123 0x68, 0x00, 0x00, 0x00, 0x00,                   //push   $0x0 (addr)
1124 0xb8, 0xdd, 0x01, 0x00, 0x00,                   //mov    $0x1dd,%eax (SYS_mmap)
1125 0x50,                                           //push   %eax (required by calling convention)
1126 0xcd, 0x80,                                     //int    $0x80
1127 0x8d, 0x64, 0x24, 0x1c,                         //lea    0x1c(%esp),%esp
1128 0xcc,                                           //trap
1129 0x90                                            //nop
1130 };
1131 const unsigned int x86_call_mmap_size = sizeof(x86_call_mmap);
1132
1133 const unsigned int x86_munmap_size_position = 1;
1134 const unsigned int x86_munmap_addr_position = 6;
1135 const unsigned int x86_munmap_start_position = 0;
1136 const unsigned char x86_call_munmap[] = {
1137 0x68, 0x00, 0x00, 0x00, 0x00,                   //push   $0x0 (size)    
1138 0x68, 0x00, 0x00, 0x00, 0x00,                   //push   $0x0 (addr)
1139 0xb8, 0x49, 0x00, 0x00, 0x00,                   //mov    $0x49,%eax (SYS_munmap)
1140 0x50,                                           //push   %eax (required by calling convention)
1141 0xcd, 0x80,                                     //int    $0x80
1142 0x8d, 0x64, 0x24, 0x0c,                         //lea    0xc(%esp),%esp 
1143 0xcc,                                           //trap
1144 0x90                                            //nop
1145 };
1146 const unsigned int x86_call_munmap_size = sizeof(x86_call_munmap);