Convert Dyninst to use StackwalkerAPI
[dyninst.git] / dyninstAPI / src / sol_proc.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 // Solaris-style /proc support
33
34 // $Id: sol_proc.C,v 1.125 2008/09/03 06:08:45 jaw Exp $
35
36 #if defined(os_aix)
37 #include <sys/procfs.h>
38 #else
39 #include <procfs.h>
40 #endif
41 #include <string>
42 #include <limits.h>
43 #include <poll.h>
44 #include <sys/types.h>  // for reading lwps out of proc
45 #include <dirent.h>     // for reading lwps out of proc
46 #include "common/h/headers.h"
47 #include "dyninstAPI/src/signalhandler.h"
48 #include "dyninstAPI/src/signalgenerator.h"
49 #include "dyninstAPI/src/process.h"
50 #include "dyninstAPI/src/dyn_lwp.h"
51 #include "dyninstAPI/src/dyn_thread.h"
52 #include "common/h/stats.h"
53 #include "common/h/pathName.h" // for path name manipulation routines
54 #include "dyninstAPI/src/sol_proc.h"
55 #include "dyninstAPI/src/os.h"
56 #include "dyninstAPI_RT/h/dyninstAPI_RT.h" // for DYNINST_BREAKPOINT_SIGNUM
57
58 #include "function.h"
59 #include "mapped_object.h"
60 #include "mapped_module.h"
61 #include "dynamiclinking.h" //getlowestSO...
62
63    void safeClose(handleT &fd) {
64       if (fd != INVALID_HANDLE_VALUE)
65          P_close(fd);
66       fd = INVALID_HANDLE_VALUE;
67    }
68
69 /*
70    osTraceMe is called after we fork a child process to set
71    a breakpoint on the exit of the exec system call.
72    When /proc is used, this breakpoint **will not** cause a SIGTRAP to 
73    be sent to the process. The parent should use PIOCWSTOP to wait for 
74    the child.
75  */
76
77
78 // Interesting problem: I've seen a race condition occur when
79 // we set the proc trace flags from the mutator before the
80 // mutatee. In this case, DON'T reset the flags if there
81 // is a stop on exec in effect.
82
83 void OS::osTraceMe(void) 
84 {
85    sysset_t *exitSet = SYSSET_ALLOC(getpid());
86    int bufsize = SYSSET_SIZE(exitSet) + sizeof(int);
87
88    char *buf = new char[bufsize];
89    int *bufptr = (int *)buf;
90    char procName[128];
91
92    // Get the current set of syscalls
93    pstatus_t status;
94    sprintf(procName,"/proc/%d/status", (int) getpid());
95    int stat_fd = P_open(procName, O_RDONLY, 0);
96    if (pread(stat_fd, (void *)&status, sizeof(pstatus_t), 0) !=
97          sizeof(pstatus_t)) {
98       fprintf(stderr, "%s[%d]:  pread: %s\n", FILE__, __LINE__, strerror(errno));
99       perror("osTraceMe::pread");
100       SYSSET_FREE(exitSet);
101       delete [] buf;
102       return;
103    }
104 #if defined(os_aix) 
105     if (status.pr_sysexit_offset) {
106         if ((ssize_t)SYSSET_SIZE(exitSet) != pread(stat_fd, exitSet, SYSSET_SIZE(exitSet), status.pr_sysexit_offset))
107        fprintf(stderr, "%s[%d]:  pread: %s\n", FILE__, __LINE__, strerror(errno));
108     }
109     else // No syscalls are being traced 
110         premptysysset(exitSet);
111 #else
112    memcpy(exitSet, &(status.pr_sysexit), SYSSET_SIZE(exitSet));
113 #endif
114    safeClose(stat_fd);
115
116    sprintf(procName,"/proc/%d/ctl", (int) getpid());
117    int fd = P_open(procName, O_WRONLY, 0);
118    if (fd < 0) {
119       perror("open");
120       SYSSET_FREE(exitSet);
121       delete [] buf;
122       return;
123    }
124
125    /* set a breakpoint at the exit of exec/execve */
126    if (SYSSET_MAP(SYS_exec, getpid()) != -1) {
127       praddsysset(exitSet, SYSSET_MAP(SYS_exec, getpid()));
128    }
129    if (SYSSET_MAP(SYS_execve, getpid()) != -1) {
130       praddsysset(exitSet, SYSSET_MAP(SYS_execve, getpid()));
131    }
132    // Write out the command
133    *bufptr = PCSEXIT; bufptr++;
134    memcpy(bufptr, exitSet, SYSSET_SIZE(exitSet));
135    if (write(fd, buf, bufsize) != bufsize) {
136       perror("osTraceMe: PCSEXIT");
137       P__exit(-1); // must use _exit here.
138    }
139
140
141    // AIX: do not close file descriptor or all changes are undone (?)
142    // My guess is we need to fiddle with the run on close/kill on 
143    // close bits. For now, leaving the FD open works.
144    //close(fd);    
145
146    SYSSET_FREE(exitSet);
147    delete [] buf;
148 }
149
150 /*
151  * DYN_LWP class
152  * Operations on LWP file descriptors, or the representative LWP
153  */
154
155 // determine if a process is running by doing low-level system checks, as
156 // opposed to checking the 'status_' member vrble.  May assume that attach()
157 // has run, but can't assume anything else.
158
159 bool dyn_lwp::isRunning() const 
160 {
161    procProcStatus_t theStatus;
162
163    if (!get_status(&theStatus)) return false;
164
165    // Don't consider PR_ASLEEP to be stopped
166    uint32_t stopped_flags = PR_STOPPED | PR_ISTOP;
167
168    if (theStatus.pr_flags & stopped_flags)
169       return false;
170    else
171       return true;
172 }
173
174 bool dyn_lwp::clearSignal() 
175 {
176    lwpstatus_t status;
177    get_status(&status);
178
179    if (status.pr_why == PR_SIGNALLED) {
180       int command[2];
181       command[0] = PCRUN; command[1] = PRSTOP | PRCSIG;
182       if (write(ctl_fd(), command, 2*sizeof(int)) != 2*sizeof(int)) {
183          perror("clearSignal: PCRUN");
184          return false;
185       }
186       command[0] = PCWSTOP;        
187       if (write(ctl_fd(), command, sizeof(int)) != sizeof(int)) {
188          perror("clearSignal: PCWSTOP");
189          return false;
190       }
191       return true;
192    }
193    else if (status.pr_why == PR_JOBCONTROL) {
194       // Someone else stopped this guy... we can't use PCRUN, we need to 
195       // use signals. Did anyone else think of linux?
196
197       // Non-blocking stop...
198       int command[2];
199       command[0] = PCDSTOP;
200       if (write(ctl_fd(), command, sizeof(int)) != sizeof(int)) {
201          perror("clearSignal: PCWSTOP");
202          return false;
203       }
204
205       // SIGCONTINUE...
206       kill(proc()->getPid(), SIGCONT);
207
208       command[0] = PCWSTOP;        
209       if (write(ctl_fd(), command, sizeof(int)) != sizeof(int)) {
210          perror("clearSignal: PCWSTOP");
211          return false;
212       }
213       return true;
214    }
215    // Uhh...
216    assert(0);
217    return false;
218 }
219
220 // Get the process running again. May do one or more of the following:
221 // 1) Continue twice to clear a signal
222 // 2) Restart an aborted system call
223 bool dyn_lwp::continueLWP_(int signalToContinueWith) 
224 {
225    procProcStatus_t status;
226    int command[2];
227    Address pc;  // PC at which we are trying to continue
228    // Check the current status
229    if (!get_status(&status)) {
230       bperr( "Failed to get LWP status\n");
231       return false;
232    }
233
234    if ((0== (status.pr_flags & PR_STOPPED)) && 
235          (0== (status.pr_flags & PR_ISTOP))) {
236       // Already running, so catch our state up.
237       return true;
238    }
239
240    // If the lwp is stopped on a signal we blip it (technical term).
241    // The process will re-stop (since we re-run with PRSTOP). At
242    // this point we continue it.
243    if ((status.pr_flags & PR_STOPPED)
244          && (status.pr_why == PR_SIGNALLED)) {
245       if (status.pr_what == SIGSTOP || 
246             status.pr_what == SIGINT ||
247             status.pr_what == SIGTRAP) {
248          clearSignal();
249       }
250    }
251
252    ptraceOps++; 
253    ptraceOtherOps++;
254
255    pc = (Address)(GETREG_PC(status.pr_reg));
256    if (stoppedInSyscall_ && pc == postsyscallpc_) {
257       if (!restartSyscall()) return false;
258    }
259
260    command[0] = PCRUN;
261    if (signalToContinueWith == NoSignal)
262       command[1] = PRCSIG;  // clear the signal
263    else {
264       command[1] = 0;
265    }
266
267   // Continue the process the easy way
268  busy_retry:
269   errno = 0;
270   signal_printf("[%s:%u] - LOW LEVEL continue happened\n", FILE__, __LINE__);
271                
272   if (write(ctl_fd(), command, 2*sizeof(int)) != 2*sizeof(int)) {
273       if (errno == EBUSY) {
274          struct timeval slp;
275          slp.tv_sec = 0;
276          slp.tv_usec = 1 /*ms*/ *1000;
277          select(0, NULL, NULL, NULL, &slp);
278          fprintf(stderr, "%s[%d]: continueLWP_, ctl_fd is busy, trying again\n", FILE__, __LINE__);
279          goto busy_retry;
280       }
281       perror("continueLWP: PCRUN2");
282       return false;
283    }
284
285    return true;
286
287 }
288
289 // Abort a system call. Place a trap at the exit of the syscall in
290 // question, and run with the ABORT flag set. Wait for the trap
291 // to be hit and then return.
292
293 bool dyn_lwp::abortSyscall()
294 {
295    lwpstatus_t status;
296
297    // MT: aborting syscalls does not work. Maybe someone with better knowledge
298    // of Solaris can get it working. 
299    if(proc_->multithread_capable(true))
300       return false;
301
302    // We do not expect to recursively interrupt system calls.  We could
303    // probably handle it by keeping a stack of system call state.  But
304    // we haven't yet seen any reason to have this functionality.
305    assert(!stoppedInSyscall_);
306    stoppedInSyscall_ = true;
307
308    if (!get_status(&status)) return false;
309
310    if (status.pr_syscall == 0 ||
311          status.pr_why == PR_SYSEXIT) {
312       // No work to be done
313       stoppedInSyscall_ = false;
314       return true;
315    }
316
317    if (((status.pr_flags & PR_STOPPED) == 0) &&
318          ((status.pr_flags & PR_ISTOP) == 0))
319       stop_();
320
321
322    sysset_t* scexit = SYSSET_ALLOC(proc_->getPid());
323    sysset_t* scsavedexit = SYSSET_ALLOC(proc_->getPid());
324    sysset_t* scentry = SYSSET_ALLOC(proc_->getPid());
325    sysset_t* scsavedentry = SYSSET_ALLOC(proc_->getPid());
326
327    // 1. Save the syscall number, registers, and blocked signals
328    stoppedSyscall_ = status.pr_syscall;
329    /*
330       memcpy(&(syscallreg_->theIntRegs), &(status.pr_reg), sizeof(prgregset_t));
331       memcpy(&(syscallreg_->theFpRegs), &(status.pr_fpreg), sizeof(prfpregset_t));
332     */   
333
334    memcpy(&sighold_, &status.pr_lwphold, sizeof(proc_sigset_t));
335
336 #ifdef i386_unknown_solaris2_5
337    // From Roger A. Faulkner at Sun (email unknown), 6/29/1997:
338    //
339    // On Intel and PowerPC machines, the system call trap instruction
340    // leaves the PC (program counter, instruction pointer) referring to
341    // the instruction that follows the system call trap instruction.
342    // On Sparc machines, the system call trap instruction leaves %pc
343    // referring to the system call trap instruction itself (the
344    // operating system increments %pc on exit from the system call).
345    //
346    // We have to reset the PC back to the system call trap instruction
347    // on Intel and PowerPC machines.
348    //
349    // This is 7 on Intel, 4 on PowerPC.
350
351    // Note: On x86/Linux this should probably be 2 bytes, because Linux
352    // uses "int" to trap, not lcall.
353
354    syscallreg_.theIntRegs[PC_REG] -= 7;
355 #endif
356
357    // 2. Abort the system call
358
359    // Save current syscall exit traps
360    proc_->get_entry_syscalls(scsavedentry);
361    proc_->get_exit_syscalls(scsavedexit);
362
363    // Set process to trap on exit from this system call
364    premptyset(scentry);
365    premptyset(scexit);
366    praddset(scexit, stoppedSyscall_);
367
368    proc_->set_entry_syscalls(scentry);
369    proc_->set_exit_syscalls(scexit);
370
371    // Continue, aborting this system call and blocking all sigs except
372    // those needed by DynInst.
373    proc_sigset_t sigs;
374    prfillset(&sigs);
375    prdelset(&sigs, SIGTRAP);
376    prdelset(&sigs, SIGILL);
377
378    // Set the signals to "ignore" and run, aborting the syscall
379 #if 0
380    int bufsize = sizeof(int) + sizeof(proc_sigset_t);
381    char buf[bufsize]; int *bufptr = (int *)buf;
382    *bufptr = PCSHOLD; bufptr++;
383    memcpy(bufptr, &sigs, sizeof(proc_sigset_t));
384
385    if (write(ctl_fd(), buf, bufsize) != bufsize) {
386       perror("abortSyscall: PCSHOLD"); return false;
387    }
388 #endif
389    int command[2];
390
391    command[0] = PCRUN;
392    command[1] = PRSABORT;
393
394    if (write(ctl_fd(), command, 2*sizeof(int)) != 2*sizeof(int)) {
395       perror("abortSyscall: PCRUN"); return false;
396    }
397
398    command[0] = PCWSTOP;
399    if (write(ctl_fd(), command, sizeof(int)) != sizeof(int)) {
400       perror("abortSyscall: PCWSTOP"); return false;
401    }
402
403    // Note: We assume that is always safe to restart the call after
404    // aborting it.  We are wrong if it turns out that some
405    // interruptible system call can make partial progress before we
406    // abort it.
407    // We think this is impossible because the proc manpage says EINTR
408    // would be returned to the process if we didn't trap the syscall
409    // exit, and the manpages for interruptible system calls say an
410    // EINTR return value means no progress was made.
411    // If we are wrong, this is probably the place to decide whether
412    // and/or how the syscall should be restarted later.
413
414    if (!get_status(&status)) return false;
415
416    // Verify that we're stopped in the right place
417    if (((status.pr_flags & (PR_STOPPED|PR_ISTOP))
418             != (PR_STOPPED|PR_ISTOP))
419          || status.pr_why != PR_SYSEXIT
420          || status.pr_syscall != stoppedSyscall_) {
421       sprintf(errorLine,
422             "warn: Can't step paused process out of syscall (Verify)\n");
423       logLine(errorLine);
424       return 0;
425    }
426
427
428    // Get a copy of the registers and save for when we restart the syscall
429    syscallreg_ = new dyn_saved_regs;
430    getRegisters(syscallreg_);
431
432    // Remember the current PC.  When we continue the process at this PC
433    // we will restart the system call.
434    postsyscallpc_ = (Address) GETREG_PC(syscallreg_->theIntRegs);
435    proc_->set_entry_syscalls(scsavedentry);
436    proc_->set_exit_syscalls(scsavedexit);
437    return true;
438 }
439
440 bool dyn_lwp::restartSyscall() 
441 {
442    if (!stoppedInSyscall_)
443       return true;
444
445    // We interrupted a sleeping system call at some previous pause
446    // (i.e. stoppedInSyscall is true), we have not restarted that
447    // system call yet, and the current PC is the insn following
448    // the interrupted call.  It is time to restart the system
449    // call.
450
451    // Note that when we make the process runnable, we ignore
452    // `flags', set if `hasNewPC' was true in the previous block,
453    // because we don't want its PC; we want the PC of the system
454    // call trap, which was saved in `syscallreg'.
455    if (!restoreRegisters(*syscallreg_)) return false;
456    delete syscallreg_;
457    syscallreg_ = NULL;
458
459    // We are done -- the process is in the kernel for the system
460    // call, with the right registers values.  Make the process
461    // runnable, restoring its previously blocked signals.
462    // The signals were blocked as part of the abort mechanism.
463    stoppedInSyscall_ = false;
464 #if 0
465    int bufsize = sizeof(int) + sizeof(proc_sigset_t);
466    char buf[bufsize]; int *bufptr = (int *)buf;
467    *bufptr = PCSHOLD; bufptr++;
468    memcpy(bufptr, &sighold_, sizeof(proc_sigset_t));
469
470    if (write(ctl_fd(), buf, bufsize) != bufsize) {
471       perror("continueLWP: PCSHOLD"); return false;
472    }
473 #endif
474    return true;
475 }
476
477
478
479 dyn_lwp *process::createRepresentativeLWP() 
480 {
481    // don't register the representativeLWP in the lwps since it's not a true
482    // lwp
483    representativeLWP = createFictionalLWP(0);
484    return representativeLWP;
485 }
486
487 // Stop the LWP in question
488 bool dyn_lwp::stop_() 
489 {
490    int command[2];
491    command[0] = PCSTOP;
492
493    signal_printf("%s[%d]: writing stop command\n", FILE__, __LINE__);
494
495    if (write(ctl_fd(), command, sizeof(int)) != sizeof(int)) {
496       fprintf(stderr, "%s[%d][%s]: ", FILE__, __LINE__, getThreadStr(getExecThreadID()));
497       perror("pauseLWP: PCSTOP");
498       return false;
499    }
500
501    return true;
502 }
503
504 // Get the registers of the stopped thread and return them.
505 bool dyn_lwp::getRegisters_(struct dyn_saved_regs *regs, bool /*includeFP*/)
506 {
507    lwpstatus_t stat;
508
509    if (status() == running) {
510       fprintf(stderr, "ERROR: status %s (proc state %s)\n",
511             processStateAsString(status()), processStateAsString(proc()->status()));
512    }
513
514    assert(status() != running);
515
516    assert(!isRunning());
517
518    if (!get_status(&stat)) return false;
519
520    // Process must be stopped for register data to be correct.
521
522    assert((stat.pr_flags & PR_STOPPED) || (stat.pr_flags & PR_ISTOP)
523          || (stat.pr_flags & PR_PCINVAL)  // eg. a trap at syscall exit
524          );
525
526    memcpy(&(regs->theIntRegs), &(stat.pr_reg), sizeof(prgregset_t));
527    memcpy(&(regs->theFpRegs), &(stat.pr_fpreg), sizeof(prfpregset_t));
528
529    return true;
530 }
531
532 void dyn_lwp::dumpRegisters()
533 {
534    dyn_saved_regs regs;
535    if (!getRegisters(&regs)) {
536       fprintf(stderr, "%s[%d]:  registers unavailable\n", FILE__, __LINE__);
537       return;
538    }
539
540    fprintf(stderr, "PC:   %lx\n", (unsigned long) GETREG_PC(regs.theIntRegs));
541    fprintf(stderr, "FP:   %lx\n", (unsigned long) GETREG_FP(regs.theIntRegs));
542    fprintf(stderr, "INFO: %lx\n", (unsigned long) GETREG_INFO(regs.theIntRegs));
543    //  plenty more register if we want to print em....
544 }
545
546 bool process::determineLWPs(pdvector<unsigned > &lwp_ids) {
547    char procdir[128];
548    snprintf(procdir, 128, "/proc/%d/lwp", getPid());
549    DIR *dirhandle = opendir(procdir);
550    if (dirhandle)
551    {
552       struct dirent *direntry;
553       while((direntry = readdir(dirhandle)) != NULL) {
554          unsigned lwp_id = atoi(direntry->d_name);
555          if (!lwp_id) continue;
556          lwp_ids.push_back(lwp_id);
557       }
558       closedir(dirhandle);
559    }
560    return true;
561 }
562
563 // Restore registers saved as above.
564 bool dyn_lwp::restoreRegisters_(const struct dyn_saved_regs &regs, bool /*includeFP*/)
565 {
566    assert(status() != running);
567
568    lwpstatus_t stat;
569    get_status(&stat);
570
571    assert(!isRunning());
572
573    // The fact that this routine can be shared between solaris/sparc and
574    // solaris/x86 is just really, really cool.  /proc rules!
575    const int regbufsize = sizeof(int) + sizeof(prgregset_t);
576    char regbuf[regbufsize]; int *regbufptr = (int *)regbuf;
577    *regbufptr = PCSREG; regbufptr++;
578    memcpy(regbufptr, &(regs.theIntRegs), sizeof(prgregset_t));
579    int writesize;
580 try_again:
581    int timeout = 2 * 1000; /*ms*/
582    int elapsed = 0;
583    errno = 0;
584    writesize = write(ctl_fd(), regbuf, regbufsize);
585
586    if (writesize != regbufsize) {
587       if (errno == EBUSY) {
588          //fprintf(stderr, "%s[%d]:  busy fd\n", FILE__, __LINE__);
589
590          struct timeval slp;
591          slp.tv_sec = 0;
592          slp.tv_usec = 1 /*ms*/ *1000;
593          select(0, NULL, NULL, NULL, &slp);
594                  elapsed += 1;
595                  if (elapsed > timeout)
596                  {
597                          fprintf(stderr, "%s[%d]:  failed to access process ctl fd\n", FILE__, __LINE__);
598                          return false;
599                  }
600          goto try_again;
601       }
602       //If this fails, we may be attaching to a mutatee in a system call
603       perror("restoreRegisters: GPR write");
604       return false;
605    }
606    const int fpbufsize = sizeof(int) + sizeof(prfpregset_t);
607    char fpbuf[fpbufsize]; int *fpbufptr = (int *)fpbuf;
608    *fpbufptr = PCSFPREG; fpbufptr++;
609    memcpy(fpbufptr, &(regs.theFpRegs), sizeof(prfpregset_t));
610
611    if (write(ctl_fd(), fpbuf, fpbufsize) != fpbufsize) {
612       perror("restoreRegisters FPR write");
613       return false;
614    }
615
616    return true;
617 }
618
619 // Determine if the LWP in question is in a system call.
620 bool dyn_lwp::executingSystemCall()
621 {
622    lwpstatus_t status;
623    if (!get_status(&status)) {
624       fprintf(stderr, "ERROR: failed to get LWP status!\n");
625       return false;
626    }
627
628    // Old-style
629
630    /*
631       fprintf(stderr, "LWP syscall value: %d, pr_why is %d, PC at 0x%lx\n",
632       status.pr_syscall, 
633       status.pr_why,
634       GETREG_PC(status.pr_reg));
635     */
636    if (status.pr_syscall > 0 && // If we're in a system call
637          status.pr_why != PR_SYSEXIT) {
638       stoppedSyscall_ = status.pr_syscall;
639       if (abortSyscall()) {
640          // Not in a syscall any more :)
641          return false;
642       }
643       else {
644          return true;
645       }
646    }
647
648 #if defined(os_aix)
649    if (status.pr_why == PR_SIGNALLED &&
650          status.pr_what == SIGSTOP) {
651       // We can't operate on a process in SIGSTOP, so clear it
652       proc()->getRepresentativeLWP()->clearSignal();
653    }
654
655    // I've seen cases where we're apparently not in a system
656    // call, but can't write registers... we'll label this case
657    // a syscall for now
658    const int regbufsize = sizeof(int) + sizeof(prgregset_t);
659    char regbuf[regbufsize]; int *regbufptr = (int *)regbuf;
660    *regbufptr = PCSREG; regbufptr++;
661    memcpy(regbufptr, &(status.pr_reg), sizeof(prgregset_t));
662    int writesize = write(ctl_fd(), regbuf, regbufsize);
663    if (writesize == -1) {
664       return true;
665    }
666 #endif
667    return false;
668 }
669
670
671 bool dyn_lwp::changePC(Address addr, struct dyn_saved_regs *regs)
672 {
673
674    // Don't change the contents of regs if given
675    dyn_saved_regs local;
676    if (!regs) {
677       getRegisters(&local);
678    } else {
679       memcpy(&local, regs, sizeof(struct dyn_saved_regs));
680    }
681
682    // Compatibility: we don't use PCSVADDR on Solaris because AIX doesn't 
683    // support it
684    // nPC MUST be set before PC! On platforms that don't have it,
685    // nPC will be overwritten by the PC write
686    GETREG_nPC(local.theIntRegs) = addr + instruction::size();
687    GETREG_PC(local.theIntRegs) = addr;
688
689    if (!restoreRegisters(local))
690       return false;
691
692    dyn_saved_regs check;
693    getRegisters(&check);
694    assert(GETREG_PC(local.theIntRegs) == GETREG_PC(check.theIntRegs));
695
696    return true;
697 }
698
699 #if defined(i386_unknown_solaris2_5)
700 bool process::changeIntReg(int reg, Address val) 
701 {
702    assert(status_ == stopped); // /proc will require this
703
704    prgregset_t theIntRegs;
705    dyn_lwp *replwp = getRepresentativeLWP();
706    if (ioctl(replwp->get_fd(), PIOCGREG, &theIntRegs) == -1) {
707       perror("dyn_lwp::changeIntReg");
708       if (errno == EBUSY) {
709          cerr << "It appears that the process wasn't stopped in the eyes of /proc" << endl;
710          assert(false);
711       }
712       return false;
713    }
714
715    theIntRegs[reg] = val;
716
717    if (ioctl(replwp->get_fd(), PIOCSREG, &theIntRegs) == -1) {
718       perror("process::changeIntReg PIOCSREG");
719       if (errno == EBUSY) {
720          cerr << "It appears that the process wasn't stopped in the eyes of /proc" << endl;
721          assert(false);
722       }
723       return false;
724    }
725
726    return true;
727 }
728 #endif
729
730 // Utility function: get the appropriate lwpstatus_t struct
731 bool dyn_lwp::get_status(lwpstatus_t *stat) const
732 {
733    if(!is_attached()) {
734       return false;
735    }
736
737    if (lwp_id_) {
738       // We're using an lwp file descriptor, so get directly
739       if (pread(status_fd_, 
740                (void *)stat, 
741                sizeof(lwpstatus_t), 0) != sizeof(lwpstatus_t)) {
742          // When we fork a LWP file might disappear.
743          fprintf(stderr, "%s[%d]:  pread: %s\n", FILE__, __LINE__, strerror(errno));
744          if ((errno != ENOENT) && (errno != EBADF)) {
745             fprintf(stderr, "%s[%d]:  dyn_lwp::get_status: %s\n", FILE__, __LINE__, strerror(errno));
746          }
747          return false;
748       }
749    }
750    else {
751       // No lwp, so we get the whole thing and pick it out
752       pstatus_t procstatus;
753       if (!proc_->get_status(&procstatus)) {
754          return false;
755       }
756       memcpy(stat, &(procstatus.pr_lwp), sizeof(lwpstatus_t));
757    }
758    return true;
759 }
760
761 // Read the value of a particular register
762 Address dyn_lwp::readRegister(Register reg)
763 {
764    Address result;
765    dyn_saved_regs regs;
766    getRegisters(&regs);
767    result = GETREG_GPR(regs.theIntRegs, reg);
768    return result;
769 }
770
771 bool dyn_lwp::realLWP_attach_() 
772 {
773    char temp[128];
774    sprintf(temp, "/proc/%d/lwp/%d/lwpctl", (int)proc_->getPid(), lwp_id_);
775    ctl_fd_ = P_open(temp, O_WRONLY, 0);
776    if (ctl_fd_ < 0) {
777       //fprintf(stderr, "%s[%d]: Opening lwpctl: %s\n", FILE__, __LINE__, strerror(errno));
778       return false;
779    }
780
781    sprintf(temp, "/proc/%d/lwp/%d/lwpstatus", (int)proc_->getPid(),lwp_id_);
782    status_fd_ = P_open(temp, O_RDONLY, 0);    
783    if (status_fd_ < 0) {
784       fprintf(stderr, "%s[%d]: Opening lwpstatus: %s\n", FILE__, __LINE__, strerror(errno));
785       safeClose(ctl_fd_);
786       return false;
787    }
788
789 #if defined(os_solaris)
790    // Find out if we're the as lwp... see comment in dyn_lwp.h
791
792    pstatus_t procstatus;
793
794    if (!proc_->get_status(&procstatus)) {
795       // Uhh....
796       return true;
797    }
798
799    if ((unsigned)procstatus.pr_aslwpid == get_lwp_id()) 
800       is_as_lwp_ = true;
801 #endif
802
803    return true;
804 }
805
806 bool dyn_lwp::representativeLWP_attach_() 
807 {
808 #if defined(os_aix) 
809    //usleep(500 * 1000);
810    //sleep(3);
811    sleep(2);
812    //sleep(1);
813 #endif
814 #if defined (os_solaris)
815    struct timeval slp;
816    slp.tv_sec = 0;
817    slp.tv_usec = 50 /*ms*/ * 1000;
818    select(0, NULL, NULL, NULL, &slp);
819 #endif
820    /*
821       Open the /proc file corresponding to process pid
822     */
823
824    char temp[128];
825    // Open the process-wise handles
826    sprintf(temp, "/proc/%d/ctl", getPid());
827
828    if (!waitForFileToExist(temp, 10 /*seconds */)) {
829       //fprintf(stderr, "%s[%d]:  cannot attach because %s does not exist\n", FILE__, __LINE__, temp);
830       return false;
831    }
832    //ctl_fd_ = openFileWhenNotBusy(temp, O_WRONLY | O_EXCL, 0, 5/*seconds*/);
833    ctl_fd_ = P_open(temp, O_WRONLY | O_EXCL, 0);    
834    if (ctl_fd_ < 0) {
835    //   fprintf(stderr, "%s[%d]: Opening (LWP) ctl: %s", FILE__, __LINE__, strerror(errno));
836    }
837
838    sprintf(temp, "/proc/%d/status", getPid());
839    if (!waitForFileToExist(temp, 5 /*seconds */)) {
840       fprintf(stderr, "%s[%d]:  cannot attach because %s does not exist\n", FILE__, __LINE__, temp);
841       return false;
842    }
843    //status_fd_ = openFileWhenNotBusy(temp, O_RDONLY, 0, 5/*seconds*/);
844    status_fd_ = P_open(temp, O_RDONLY, 0);    
845    if (status_fd_ < 0) {
846         //fprintf(stderr, "%s[%d]: Opening (LWP) status: %s", FILE__, __LINE__, strerror(errno));
847    } 
848
849    as_fd_ = INVALID_HANDLE_VALUE;
850    sprintf(temp, "/proc/%d/as", getPid());
851    if (!waitForFileToExist(temp, 5 /*seconds */)) {
852       fprintf(stderr, "%s[%d]:  cannot attach because %s does not exist\n", FILE__, __LINE__, temp);
853       return false;
854    }
855    //as_fd_ = openFileWhenNotBusy(temp, O_RDWR, 0, 5/*seconds*/);
856    as_fd_ = P_open(temp, O_RDWR, 0);
857    if (as_fd_ < 0) {
858         //fprintf(stderr, "%s[%d]: Opening as fd: %s", FILE__, __LINE__, strerror(errno));
859    }
860
861 #if !defined(os_aix)
862    sprintf(temp, "/proc/%d/auxv", getPid());
863    if (!waitForFileToExist(temp, 5 /*seconds */)) {
864       fprintf(stderr, "%s[%d]:  cannot attach because %s does not exist\n", FILE__, __LINE__, temp);
865       return false;
866    }
867    //auxv_fd_ = openFileWhenNotBusy(temp, O_RDONLY, 0, 5/*seconds*/);
868    auxv_fd_ = P_open(temp, O_RDONLY, 0);
869    if (auxv_fd_ < 0) {
870    //   fprintf(stderr, "%s[%d]: Opening auxv fd: %s", FILE__, __LINE__, strerror(errno));
871    }
872 #else
873    // AIX doesn't have the auxv file
874    auxv_fd_ = INVALID_HANDLE_VALUE;
875 #endif
876
877    sprintf(temp, "/proc/%d/map", getPid());
878    if (!waitForFileToExist(temp, 5 /*seconds */)) {
879       //fprintf(stderr, "%s[%d]:  cannot attach because %s does not exist\n", FILE__, __LINE__, temp);
880       return false;
881    }
882    //map_fd_ = openFileWhenNotBusy(temp, O_RDONLY, 0, 5/*seconds*/);
883    map_fd_ = P_open(temp, O_RDONLY, 0);
884    if (map_fd_ < 0) {
885         //fprintf(stderr, "%s[%d]:  map_fd: %s\n", FILE__, __LINE__, strerror(errno));
886   }
887
888    sprintf(temp, "/proc/%d/psinfo", getPid());
889    if (!waitForFileToExist(temp, 5 /*seconds */)) {
890       //fprintf(stderr, "%s[%d]:  cannot attach because %s does not exist\n", FILE__, __LINE__, temp);
891       return false;
892    }
893    //ps_fd_ = openFileWhenNotBusy(temp, O_RDONLY, 0, 5/*seconds*/);
894    ps_fd_ = P_open(temp, O_RDONLY, 0);
895    if (ps_fd_ < 0) {
896         //fprintf(stderr, "%s[%d]: Opening ps fd: %s", FILE__, __LINE__, strerror(errno));
897    }
898    is_attached_ = true;
899
900    if (isRunning()) {
901       // Stop the process; we want it paused post-attach
902       stop_();
903    }
904
905    // special for aix: we grab the status and clear the STOP
906    // signal (if any)
907    lwpstatus_t stat;
908    get_status(&stat);
909
910    if (((stat.pr_why == PR_SIGNALLED) ||
911             (stat.pr_why == PR_JOBCONTROL)) &&
912          (stat.pr_what == SIGSTOP)) {
913       clearSignal();
914    }
915
916    //  if we attached to a running process, it might be stuck in a syscall,
917    //  try to abort it
918    if (proc()->wasCreatedViaAttach()) {
919       // Abort a system call if we're in it
920       abortSyscall();
921    }
922
923    return true;
924 }
925
926 // Close FDs opened above
927 void dyn_lwp::realLWP_detach_()
928 {
929    assert(is_attached());  // dyn_lwp::detach() shouldn't call us otherwise
930
931    // First we want to clear any signal which might be pending
932    // for the process. Otherwise, when we detach the process has
933    // a signal sent that it may have no clue about
934    // But we can't do that here -- all FDs associated with the process
935    // are closed. 
936    safeClose(ctl_fd_);
937    safeClose(status_fd_);
938    safeClose(as_fd_);
939    safeClose(auxv_fd_);
940    safeClose(map_fd_);
941    safeClose(ps_fd_);
942
943    is_attached_ = false;
944 }
945
946 // Close FDs opened above
947 void dyn_lwp::representativeLWP_detach_()
948 {
949    assert(is_attached());  // dyn_lwp::detach() shouldn't call us otherwise
950
951    // First we want to clear any signal which might be pending
952    // for the process. Otherwise, when we detach the process has
953    // a signal sent that it may have no clue about
954    // But we can't do that here -- all FDs associated with the process
955    // are closed.
956    safeClose(ctl_fd_);
957    safeClose(status_fd_);
958    safeClose(as_fd_);
959    safeClose(auxv_fd_);
960    safeClose(map_fd_);
961    safeClose(ps_fd_);
962
963    is_attached_ = false;
964 }
965
966 /*
967  * Process-wide /proc operations
968  */
969
970 bool process::setProcessFlags()
971 {
972    int command[2];
973
974    // Unset all flags
975    command[0] = PCUNSET;
976    command[1] = PR_BPTADJ | PR_MSACCT | PR_RLC | PR_KLC | PR_FORK;
977
978    dyn_lwp *replwp = getRepresentativeLWP();
979    if (write(replwp->ctl_fd(), command, 2*sizeof(int)) != 2*sizeof(int)) {
980 //      perror("installProcessFlags: PRUNSET");
981       return false;
982    }
983    command[0] = PCSET;
984    command[1] = PR_BPTADJ | PR_MSACCT | PR_FORK;
985
986    if (write(replwp->ctl_fd(), command, 2*sizeof(int)) != 2*sizeof(int)) {
987 //      perror("installProcessFlags: PCSET");
988       return false;
989    }
990
991    // step 2) /proc PIOCSTRACE: define which signals should be
992    // forwarded to daemon These are (1) SIGSTOP and (2) either
993    // SIGTRAP (sparc) or SIGILL (x86), to implement inferiorRPC
994    // completion detection.
995    // Also detect SIGCONT so that we know if a user has restarted
996    // an application.
997
998    proc_sigset_t sigs;
999
1000    premptyset(&sigs);
1001    praddset(&sigs, SIGSTOP);
1002    praddset(&sigs, DYNINST_BREAKPOINT_SIGNUM);
1003
1004    praddset(&sigs, SIGTRAP);
1005
1006    praddset(&sigs, SIGCONT);
1007    praddset(&sigs, SIGBUS);
1008    praddset(&sigs, SIGSEGV);
1009    praddset(&sigs, SIGILL);
1010
1011    const int bufsize = sizeof(int) + sizeof(proc_sigset_t);
1012    char buf[bufsize];
1013    int *bufptr = (int *) buf;
1014    *bufptr = PCSTRACE;
1015    bufptr++;
1016    memcpy(bufptr, &sigs, sizeof(proc_sigset_t));
1017
1018    if(write(replwp->ctl_fd(), buf, bufsize) != bufsize) {
1019       perror("attach: PCSTRACE");
1020       return false;
1021    }
1022
1023    return true;
1024 }
1025
1026 bool process::unsetProcessFlags()
1027 {
1028    int command[2];
1029
1030    if (!isAttached()) return false;
1031    // Unset all flags
1032    command[0] = PCUNSET;
1033    command[1] = PR_BPTADJ | PR_MSACCT | PR_RLC | PR_KLC | PR_FORK;
1034
1035    dyn_lwp *replwp = getRepresentativeLWP();
1036    if (write(replwp->ctl_fd(), command, 2*sizeof(int)) != 2*sizeof(int)) {
1037       perror("unsetProcessFlags: PRUNSET");
1038       return false;
1039    }
1040
1041    proc_sigset_t sigs;
1042    premptyset(&sigs);
1043    const int sigbufsize = sizeof(int) + sizeof(proc_sigset_t);
1044    char sigbuf[sigbufsize]; int *sigbufptr = (int *)sigbuf;
1045
1046    sigbufptr = (int *)sigbuf;
1047    *sigbufptr = PCSTRACE;
1048    if (write(replwp->ctl_fd(), sigbuf, sigbufsize) != sigbufsize) {
1049       perror("unsetProcessFlags: PCSTRACE");
1050       return false;
1051    }
1052
1053    return true;
1054 }
1055
1056 // AIX requires us to re-open the process-wide handles after
1057 // an exec call
1058
1059 #if defined(os_aix)
1060 void dyn_lwp::reopen_fds() {
1061    // Reopen the process-wide handles
1062    char temp[128];
1063
1064    P_close(as_fd_);
1065    sprintf(temp, "/proc/%d/as", getPid());
1066    as_fd_ = P_open(temp, O_RDWR, 0);
1067    if (as_fd_ <= 0) perror("Opening as fd");
1068 #if !defined(os_aix)
1069    P_close(auxv_fd_);
1070    sprintf(temp, "/proc/%d/auxv", getPid());
1071    auxv_fd_ = P_open(temp, O_RDONLY, 0);
1072    if (auxv_fd_ <= 0) perror("Opening auxv fd");
1073 #else
1074    // AIX doesn't have the auxv file
1075    auxv_fd_ = INVALID_HANDLE_VALUE;
1076 #endif
1077
1078    P_close(map_fd_);
1079    sprintf(temp, "/proc/%d/map", getPid());
1080    map_fd_ = P_open(temp, O_RDONLY, 0);
1081    if (map_fd_ <= 0) perror("map fd");
1082
1083    P_close(ps_fd_);
1084    sprintf(temp, "/proc/%d/psinfo", getPid());
1085    ps_fd_ = P_open(temp, O_RDONLY, 0);
1086    if (ps_fd_ <= 0) perror("Opening ps fd");
1087
1088    P_close(status_fd_);
1089    sprintf(temp, "/proc/%d/status", getPid());
1090    status_fd_ = P_open(temp, O_RDONLY, 0);
1091    if (status_fd_ <= 0) perror("Opening status fd");
1092 }
1093 #endif
1094
1095 bool process::isRunning_() const 
1096 {
1097    if (getRepresentativeLWP() &&
1098          isAttached())
1099       return getRepresentativeLWP()->isRunning();
1100
1101    // Let's assume nothing is open....
1102    char temp[128];
1103    int status_fd;
1104
1105    sprintf(temp, "/proc/%d/status", getPid());
1106    status_fd = P_open(temp, O_RDONLY, 0);
1107    if (status_fd <= 0) return false;
1108
1109    pstatus_t procstatus;
1110    size_t sz_read = pread(status_fd, (void *)&procstatus, sizeof(pstatus_t), 0);
1111    close(status_fd);
1112
1113    if (sz_read != sizeof(pstatus_t)) {
1114       fprintf(stderr, "%s[%d]:  pread: %s\n", FILE__, __LINE__, strerror(errno));
1115       return false;
1116    }
1117
1118    uint32_t stopped_flags = PR_STOPPED | PR_ISTOP;
1119
1120    if (procstatus.pr_flags & stopped_flags) {
1121       return false;
1122    }
1123    return true;
1124 }
1125
1126 /*
1127    terminate execution of a process
1128  */
1129 terminateProcStatus_t process::terminateProc_()
1130 {
1131    // Two kill methods: polite and unpolite. Not sure why we use
1132    // polite, but hey...
1133
1134    // Polite: we're attached, and use a /proc command.
1135    // Unpolite: we're not attached, and kill -9
1136
1137    if (isAttached()) {
1138       // these next two lines are a hack used to get the poll call initiated
1139       // by checkForAndHandleProcessEvents() in process::terminateProc to
1140       // still check process for events if it was previously stopped
1141       if(status() == stopped)
1142          status_ = running;
1143
1144       int command[2];
1145       command[0] = PCKILL;
1146       command[1] = SIGKILL;
1147       dyn_lwp *cntl_lwp = getRepresentativeLWP();
1148       if (cntl_lwp) {
1149          if (write(cntl_lwp->ctl_fd(), 
1150                   command, 2*sizeof(int)) != 2*sizeof(int)) {
1151             // TODO: what gets returned if the process is already dead?
1152             // proc man page doesn't say.
1153             return terminateFailed;
1154          }
1155          return terminateSucceeded;
1156       }
1157       else {
1158          // Uh...
1159          return terminateFailed;
1160       }
1161    }
1162    else {
1163       // We may be detached. Go for it the old-fashioned way.
1164       if (kill( getPid(), SIGKILL )) {
1165          return terminateFailed;
1166       }
1167       else {
1168          // alreadyTerminated... since we don't want to wait
1169          // for a "I'm dead" message.
1170          return alreadyTerminated;
1171       }
1172    }
1173    assert(0 && "Unreachable");
1174    return terminateFailed;
1175 }
1176
1177 bool dyn_lwp::waitUntilStopped() 
1178 {
1179    signal_printf("%s[%d]: waiting until stopped, process status %s\n", FILE__, __LINE__, proc()->getStatusAsString().c_str());
1180    pdvector<eventType> evts;
1181    eventType evt;
1182
1183    // This ensures that we don't start running accidentally...
1184    processRunState_t oldState = proc()->sh->overrideSyncContinueState(stopRequest);
1185
1186    while (proc()->status() != stopped) {
1187       if (proc()->status() == exited) break;
1188       evts.push_back(evtAnyEvent);
1189       signal_printf("%s[%d]: waiting for event in waitUntilStopped...\n", FILE__, __LINE__);
1190       evt = proc()->sh->waitForOneOf(evts);
1191       signal_printf("%s[%d]: got event in waitUntilStopped, process status %s\n", FILE__, __LINE__, proc()->getStatusAsString().c_str());
1192    }
1193
1194    signal_printf("%s[%d]: stopped...\n", FILE__, __LINE__);
1195    // And now put things back the way they were.
1196    proc()->sh->overrideSyncContinueState(oldState);
1197
1198    return true;
1199 }
1200
1201 // I'm not sure this version is ever called...
1202 bool process::waitUntilStopped() 
1203 {
1204    signal_printf("%s[%d]: waiting until stopped, process status %s\n", FILE__, __LINE__, getStatusAsString().c_str());
1205    pdvector<eventType> evts;
1206    eventType evt;
1207
1208    while (status() != stopped) {
1209       if (status() == exited) break;
1210       evts.push_back(evtAnyEvent);
1211       signal_printf("%s[%d]: waiting for event in waitUntilStopped...\n", FILE__, __LINE__);
1212       evt = sh->waitForOneOf(evts);
1213       signal_printf("%s[%d]: got event in waitUntilStopped, process status %s\n", FILE__, __LINE__, getStatusAsString().c_str());
1214    }
1215
1216    signal_printf("%s[%d]: stopped...\n", FILE__, __LINE__);
1217
1218    return true;
1219 }
1220
1221 bool dyn_lwp::writeTextWord(caddr_t inTraced, int data) 
1222 {
1223    //  cerr << "writeTextWord @ " << (void *)inTraced << endl; cerr.flush();
1224    bool ret =  writeDataSpace(inTraced, sizeof(int), (caddr_t) &data);
1225    if (!ret) fprintf(stderr, "%s[%d][%s]:  writeDataSpace failed\n",
1226          FILE__, __LINE__, getThreadStr(getExecThreadID()));
1227    assert(ret);
1228    return ret;
1229 }
1230
1231 bool dyn_lwp::writeTextSpace(void *inTraced, u_int amount, const void *inSelf)
1232 {
1233    //  cerr << "writeTextSpace pid=" << getPid() << ", @ " << (void *)inTraced
1234    //       << " len=" << amount << endl; cerr.flush();
1235    bool ret =  writeDataSpace(inTraced, amount, inSelf);
1236    if (!ret) fprintf(stderr, "%s[%d][%s]:  writeDataSpace failed\n",
1237          FILE__, __LINE__, getThreadStr(getExecThreadID()));
1238    assert(ret);
1239    return ret;
1240 }
1241
1242 bool dyn_lwp::readTextSpace(const void *inTraced, u_int amount, void *inSelf) 
1243 {
1244    return readDataSpace(inTraced, amount, inSelf);
1245 }
1246
1247 bool dyn_lwp::writeDataSpace(void *inTraced, u_int amount, const void *inSelf)
1248 {
1249    //fprintf(stderr, "%s[%d][%s]:  writeDataSpace: %p\n", FILE__, __LINE__, getThreadStr(getExecThreadID()), inTraced);
1250    ptraceOps++; ptraceBytes += amount;
1251
1252    //  cerr << "process::writeDataSpace_ pid " << getPid() << " writing "
1253    //       << amount << " bytes at loc " << inTraced << endl;
1254    off64_t loc;
1255    // Problem: we may be getting a address with the high bit
1256    // set. So how to convince the system that it's not negative?
1257    loc = (off64_t) ((unsigned long) inTraced);
1258
1259    errno = 0;
1260
1261    int written = pwrite64(as_fd(), inSelf, amount, loc);
1262    if (written != (int)amount) {
1263       fprintf(stderr, "%s[%d][%s]:  writeDataSpace: %s\n", FILE__, __LINE__, getThreadStr(getExecThreadID()), strerror(errno));
1264       perror("writeDataSpace");
1265       //assert(0);
1266       return false;
1267    }
1268
1269    return true;
1270 }
1271
1272 bool dyn_lwp::readDataSpace(const void *inTraced, u_int amount, void *inSelf) 
1273 {
1274    ptraceOps++; ptraceBytes += amount;
1275
1276    off64_t loc;
1277    loc = (off64_t)((unsigned long)inTraced);
1278
1279    int res = pread64(as_fd(), inSelf, amount, loc);
1280    //fprintf(stderr, "%s[%d][%s]:  %d = readDataSpace(%p, amt=%d, %p)\n",
1281    //       FILE__, __LINE__, getThreadStr(getExecThreadID()), res,
1282    //       inTraced, amount, inSelf);
1283    if (res != (int) amount) {
1284       fprintf(stderr, "%s[%d]:  pread: %s\n", FILE__, __LINE__, strerror(errno));
1285       /*
1286       // Commented out; the top-level call will print an error if desired.
1287       perror("readDataSpace");
1288       bperr( "From 0x%x (mutator) to 0x%x (mutatee), %d bytes, got %d\n",
1289       (int)inSelf, (int)inTraced, amount, res);
1290        */
1291       return false;
1292    }
1293    return true;
1294 }
1295
1296
1297 bool process::get_status(pstatus_t *status) const
1298 {
1299    if (!isAttached()) return false;
1300    if (!getRepresentativeLWP()->is_attached()) return false;
1301
1302    int readfd = getRepresentativeLWP()->status_fd();
1303    size_t sz_read = pread(readfd, (void *)status, sizeof(pstatus_t), 0);
1304    if (sz_read != sizeof(pstatus_t)) {
1305 /*
1306       fprintf(stderr, "[%s][%d]: process::get_status: %s\n", FILE__, __LINE__, strerror(errno));
1307       fprintf(stderr, "[%s][%d]: pread returned %d instead of %d, fd = %d\n", FILE__, __LINE__, sz_read, sizeof(pstatus_t), readfd);
1308       perror("pread");
1309 */      
1310       return false;
1311    }
1312
1313    return true;
1314 }
1315
1316 bool process::set_entry_syscalls(sysset_t *entry)
1317 {
1318    if (!isAttached()) return false;
1319
1320    int bufentrysize = sizeof(int) + SYSSET_SIZE(entry);
1321    char *bufentry = new char[bufentrysize]; int *bufptr = (int *)bufentry;
1322
1323    // Write entry syscalls
1324    *bufptr = PCSENTRY; bufptr++;
1325    memcpy(bufptr, entry, SYSSET_SIZE(entry));
1326
1327    dyn_lwp *replwp = getRepresentativeLWP();
1328
1329    if (write(replwp->ctl_fd(), bufentry, bufentrysize) != bufentrysize){
1330       delete [] bufentry;
1331       return false;
1332    }
1333
1334    delete [] bufentry;
1335    return true;    
1336 }
1337
1338 bool process::set_exit_syscalls(sysset_t *exit)
1339 {
1340    if (!isAttached()) return false;
1341
1342    int bufexitsize = sizeof(int) + SYSSET_SIZE(exit);
1343    char *bufexit = new char[bufexitsize]; int *bufptr = (int *)bufexit;
1344    *bufptr = PCSEXIT; bufptr++;
1345    memcpy(bufptr, exit, SYSSET_SIZE(exit));
1346
1347    dyn_lwp *replwp = getRepresentativeLWP();        
1348    if (write(replwp->ctl_fd(), bufexit, bufexitsize) != bufexitsize){
1349       delete [] bufexit;
1350       return false;
1351    }
1352    delete [] bufexit;
1353    return true;    
1354 }
1355
1356 syscallTrap *process::trapSyscallExitInternal(Address syscall)
1357 {
1358    syscallTrap *trappedSyscall = NULL;
1359
1360    // First, the cross-platform bit. If we're already trapping
1361    // on this syscall, then increment the reference counter
1362    // and return
1363
1364    for (unsigned iter = 0; iter < syscallTraps_.size(); iter++) {
1365       if (syscallTraps_[iter]->syscall_id == syscall) {
1366          trappedSyscall = syscallTraps_[iter];
1367          break;
1368       }
1369    }
1370
1371    if (trappedSyscall) {
1372       // That was easy...
1373       trappedSyscall->refcount++;
1374       //bperr( "Bumping refcount for syscall %d to %d\n",
1375       //        (int)trappedSyscall->syscall_id, trappedSyscall->refcount);
1376       return trappedSyscall;
1377    }
1378    else {
1379       // Okay, we haven't trapped this system call yet.
1380       // Things to do:
1381       // 1) Get the original value
1382       // 2) Place a trap
1383       // 3) Create a new syscallTrap object and return it
1384       trappedSyscall = new syscallTrap;
1385       trappedSyscall->refcount = 1;
1386       trappedSyscall->syscall_id = (int) syscall;
1387
1388       //bperr( "  trapping syscall %d for 1st time (%d)\n",
1389       //       (int)trappedSyscall->syscall_id, trappedSyscall->refcount);
1390
1391 #if defined(os_aix) 
1392       // AIX does some weird things, as we can't modify a thread
1393       // at a system call exit -- this means that using /proc
1394       // doesn't get us anywhere.
1395       // The "address" of the system call is actually the LWP
1396       // in the call
1397       dyn_lwp *syslwp = getLWP((unsigned) syscall);
1398       Frame frame = syslwp->getActiveFrame();
1399       Frame callerFrame = frame.getCallerFrame();
1400
1401       Address origLR;
1402       readDataSpace((void *)(callerFrame.getFP() + 8),
1403             sizeof(Address),
1404             (void *)&origLR, false);
1405       trappedSyscall->origLR = origLR;
1406
1407       Address trapAddr = inferiorMalloc(instruction::size());
1408       trappedSyscall->trapAddr = trapAddr;
1409
1410       codeGen gen(instruction::size());
1411       insnCodeGen::generateTrap(gen);
1412
1413       bool ret = writeDataSpace((void *)trapAddr, 
1414             gen.used(),
1415             gen.start_ptr());
1416       if (!ret) fprintf(stderr, "%s[%d][%s]:  writeDataSpace failed\n",
1417             FILE__, __LINE__, getThreadStr(getExecThreadID()));
1418       writeDataSpace((void *)(callerFrame.getFP() + 8), 
1419             sizeof(Address),
1420             (void *)&trapAddr);
1421
1422       signal_printf("%s[%d]: LWP placing syscall trap at addr 0x%lx\n",
1423             FILE__, __LINE__, trapAddr);
1424
1425       if (!ret) fprintf(stderr, "%s[%d][%s]:  writeDataSpace failed\n",
1426             FILE__, __LINE__, getThreadStr(getExecThreadID()));
1427       assert(ret);
1428 #else
1429       sysset_t *cur_syscalls = SYSSET_ALLOC(getPid());
1430
1431       if (!get_exit_syscalls(cur_syscalls)) return NULL;
1432       if (prissyssetmember(cur_syscalls, trappedSyscall->syscall_id))
1433          // Surprising case... but it's possible as we trap fork and exec
1434          trappedSyscall->orig_setting = 1;
1435       else
1436          trappedSyscall->orig_setting = 0;
1437
1438       // 2) Place a trap
1439       praddsysset(cur_syscalls, trappedSyscall->syscall_id);
1440       if (!set_exit_syscalls(cur_syscalls)) return false;
1441
1442       //bperr("PCSexit for %d, orig %d\n", 
1443       //trappedSyscall->syscall_id, trappedSyscall->orig_setting);
1444 #endif
1445       // Insert into the list of trapped syscalls
1446 #if 0
1447       syscallTraps_ += (trappedSyscall);
1448 #endif
1449       syscallTraps_.push_back(trappedSyscall);
1450
1451       return trappedSyscall;
1452    }
1453    // Should never reach here.
1454    return NULL;
1455 }
1456
1457 bool process::clearSyscallTrapInternal(syscallTrap *trappedSyscall) 
1458 {
1459    // Decrement the reference count, and if it's 0 remove the trapped
1460    // system call
1461    assert(trappedSyscall->refcount > 0);
1462
1463    trappedSyscall->refcount--;
1464
1465    if (trappedSyscall->refcount > 0) {
1466       //bperr( "Refcount on syscall %d reduced to %d\n",
1467       //        (int)trappedSyscall->syscall_id,
1468       //        trappedSyscall->refcount);
1469       return true;
1470    }
1471    // Erk... it hit 0. Remove the trap at the system call
1472
1473 #if defined(os_aix)
1474    inferiorFree(trappedSyscall->trapAddr);
1475 #else
1476    sysset_t *cur_syscalls = SYSSET_ALLOC(getPid());
1477
1478    if (!get_exit_syscalls(cur_syscalls)) return false;
1479    if (!trappedSyscall->orig_setting) {
1480       prdelsysset(cur_syscalls, trappedSyscall->syscall_id);
1481    }
1482
1483    if (!set_exit_syscalls(cur_syscalls)) return false;
1484
1485
1486 #endif
1487    // Now that we've reset the original behavior, remove this
1488    // entry from the vector
1489    pdvector<syscallTrap *> newSyscallTraps;
1490    for (unsigned iter = 0; iter < syscallTraps_.size(); iter++) {
1491       if (trappedSyscall != syscallTraps_[iter])
1492          newSyscallTraps.push_back(syscallTraps_[iter]);
1493    }
1494    syscallTraps_ = newSyscallTraps;
1495    delete trappedSyscall;
1496
1497    return true;
1498 }
1499
1500 Address dyn_lwp::getCurrentSyscall() {
1501
1502    // Return the system call we're currently in
1503    lwpstatus_t status;
1504    if (!get_status(&status)) {
1505       bperr( "Failed to get status\n");
1506       return 0;
1507    }
1508 #if defined(os_aix)
1509    // lwps stopped in syscalls are unmodifiable.. so we 'fake' it
1510    return get_lwp_id();
1511 #endif
1512
1513    return status.pr_syscall;
1514 }
1515
1516
1517
1518 bool dyn_lwp::stepPastSyscallTrap()
1519 {
1520 #if defined(os_aix)
1521    // We trap the exit, as lwps stopped in syscalls are unmodifiable
1522    changePC(trappedSyscall_->origLR, NULL);
1523 #endif
1524    // Nice... on /proc systems we don't need to do anything here
1525    return true;
1526 }
1527
1528 // Check if a LWP has hit a trap we inserted to catch the exit of a
1529 // system call trap.
1530 // Return values:
1531 // 0: did not trap at the exit of a syscall
1532 // 1: Trapped, but did not have a syscall trap placed for this LWP
1533 // 2: Trapped with a syscall trap desired.
1534 #if defined(os_aix) 
1535 bool dyn_lwp::decodeSyscallTrap(EventRecord &ev) 
1536 {
1537    if (!trappedSyscall_) return false;
1538
1539    Frame frame = getActiveFrame();
1540
1541    if (frame.getPC() == trappedSyscall_->trapAddr) {
1542       ev.type = evtSyscallExit;
1543       ev.what = procSysOther;
1544       ev.info = trappedSyscall_->syscall_id;
1545       return true;
1546    }
1547
1548    return false;
1549 }
1550 #else
1551 bool dyn_lwp::decodeSyscallTrap(EventRecord & /* ev */) 
1552 {
1553    return true;
1554 }
1555 #endif
1556
1557 int showProcStatus(lwpstatus_t status)
1558 {
1559    switch (status.pr_why) {
1560       case PR_SIGNALLED:
1561          cerr << "PR_SIGNALED, what: " << (int)status.pr_what << endl;
1562          break;
1563       case PR_SYSENTRY:
1564          cerr << "PR_SYSENTRY, what: " << (int)status.pr_what << endl;
1565          break;
1566       case PR_SYSEXIT:
1567          cerr << "PR_SYSEXIT, what: " << (int)status.pr_what << endl;
1568          break;
1569       case PR_REQUESTED:
1570          cerr << "PR_REQUESTED\n";
1571          break;
1572 #if defined(PR_SUSPENDED)
1573       case PR_SUSPENDED:
1574          // I'm seeing this state at times with a forking multi-threaded
1575          // child process, currently handling by just continuing the process
1576          cerr << "PR_SUSPENDED\n";
1577          break;
1578 #endif
1579       case PR_JOBCONTROL:
1580       case PR_FAULTED:
1581       default:
1582          cerr << "OTHER\n";
1583          assert(0);
1584          break;
1585    }
1586    return 1;
1587 }
1588
1589 bool find_matching_event(pdvector<EventRecord> &events,
1590       EventRecord &ev,
1591       EventRecord &matching_ev) 
1592 {
1593    bool found = false;
1594    process *proc = ev.proc;
1595    for(unsigned i=0; i<events.size(); i++) {
1596       EventRecord *cur_event = &(events[i]);
1597       if(cur_event->proc == proc && cur_event->type == ev.type &&
1598             cur_event->what == ev.what) {
1599          // assume that there's at most one matching event
1600          assert(!found);
1601          matching_ev = *cur_event;
1602          found = true;
1603       }
1604    }
1605
1606    return found;
1607 }
1608
1609
1610 bool SignalGenerator::decodeEvents(pdvector<EventRecord> &events)
1611 {
1612    assert(events.size() > 0);
1613    signal_printf("%s[%d]: decodeEvents entry, %d queued events\n",
1614          FILE__, __LINE__, events.size());
1615
1616    // There'll only ever be one... Highlander!
1617    for (unsigned i = 0; i < events.size(); i++) {
1618       EventRecord &ev = events[i];
1619
1620       if ((ev.info & POLLHUP) || (ev.info & POLLNVAL)) {
1621          // True if the process exited out from under us
1622          ev.lwp = ev.proc->getRepresentativeLWP();
1623          int status;
1624          int ret; 
1625          do {
1626             ret = waitpid(getPid(), &status, 0);
1627          } while ((ret < 0) && (errno == EINTR));
1628          if (ret < 0) { 
1629             //  if we get ECHILD it just means that the child process no longer exists.
1630             //  just create an exit event and keep quiet
1631             if (errno != ECHILD) {
1632                fprintf(stderr, "%s[%d]:  This shouldn't happen\n", FILE__, __LINE__);         
1633                perror("waitpid");
1634             }
1635             //  but really it _should_ be our child since 
1636             ev.type = evtProcessExit;
1637             ev.what = 0;
1638             ev.status = statusNormal; // If he exited via a signal, that gets handled in decodeWaitPidStatus
1639             status = 0;
1640             continue;
1641          }
1642
1643          if (!decodeWaitPidStatus(status, ev)) {
1644             fprintf(stderr, "%s[%d]:  failed to decodeWaitPidStatus\n", FILE__, __LINE__);
1645             continue;
1646          }
1647          signal_printf("%s[%d]: after waitPidStatus, event %s\n",
1648                FILE__, __LINE__, eventType2str(ev.type));
1649
1650          if (ev.type == evtSignalled && !decodeSignal(ev)) {
1651             fprintf(stderr, "%s[%d]:  failed to decodeSignal\n", FILE__, __LINE__);
1652             continue;
1653          }
1654
1655          if (ev.type == evtUndefined) {
1656             fprintf(stderr, "%s[%d]:  undefined event\n", FILE__, __LINE__);
1657             continue;
1658          }
1659
1660          signal_printf("%s[%d]:  new event: %s\n", FILE__, __LINE__, eventType2str(ev.type));
1661          continue;
1662       }
1663
1664       procProcStatus_t procstatus;
1665       if(! ev.proc->getRepresentativeLWP()->get_status(&procstatus)) {
1666          if (ev.type == evtUndefined) {
1667             ev.type = evtProcessExit;
1668             fprintf(stderr, "%s[%d]:  file desc for process exit not available\n",
1669                   FILE__, __LINE__);
1670             continue;
1671          }
1672          fprintf(stderr, "%s[%d]:  file desc for %s not available\n",
1673                FILE__, __LINE__, eventType2str(ev.type));
1674          continue;
1675       }
1676
1677       signal_printf("Thread status flags: 0x%x (STOPPED %d, ISTOP %d, ASLEEP %d)\n",
1678             procstatus.pr_flags,
1679             procstatus.pr_flags & PR_STOPPED,
1680             procstatus.pr_flags & PR_ISTOP,
1681             procstatus.pr_flags & PR_ASLEEP);
1682       signal_printf("Current signal: %d, reason for stopping: %d, (REQ %d, SIG %d, ENT %d, EXIT %d), what %d\n",
1683             procstatus.pr_cursig, procstatus.pr_why,
1684             procstatus.pr_why == PR_REQUESTED,
1685             procstatus.pr_why == PR_SIGNALLED,
1686             procstatus.pr_why == PR_SYSENTRY,
1687             procstatus.pr_why == PR_SYSEXIT,
1688             procstatus.pr_what);
1689
1690       signal_printf("Signal encountered on LWP %d\n", procstatus.pr_lwpid);
1691
1692       // copied from old code, must not care about events that don't stop proc
1693       // Actually, this happens if we've requested a stop but didn't wait for it; the process
1694       // is _actually_ running although we had thought it stopped.
1695       if ( !(procstatus.pr_flags & PR_STOPPED || procstatus.pr_flags & PR_ISTOP) ) {
1696          ev.proc->set_status(running);
1697          ev.type = evtIgnore;
1698          signal_printf("%s[%d]:  new event: %s\n",
1699                FILE__, __LINE__, eventType2str(ev.type));
1700          continue;
1701       }
1702
1703       //  find the right dyn_lwp to work with
1704       /* unsigned target_lwp_id = (unsigned) procstatus.pr_lwpid; */
1705       dyn_lwp *lwp_to_use = ev.proc->getRepresentativeLWP();
1706       bool updated_events = false;
1707
1708       if (ev.proc->real_lwps.size()) {
1709          if (ev.proc->real_lwps.find((unsigned) procstatus.pr_lwpid))
1710             lwp_to_use  = ev.proc->real_lwps[procstatus.pr_lwpid];
1711          else {
1712             lwp_to_use = ev.proc->getLWP(procstatus.pr_lwpid);
1713          }
1714       }
1715
1716       ev.lwp = lwp_to_use;
1717       if (!ev.lwp) {
1718          fprintf(stderr, "%s[%d]:  no lwp, returning NULL event\n", FILE__, __LINE__);
1719          ev.type = evtNullEvent;
1720          return false;
1721       }
1722
1723       signal_printf("%s[%d]: decodeEvents, calling decodeProcStatus...\n",
1724             FILE__, __LINE__);
1725
1726       // Now decode the sucker
1727       if (!decodeProcStatus(procstatus, ev)) {
1728          fprintf(stderr, "%s[%d]:  failed to decodeProcStatus\n", FILE__, __LINE__);
1729          continue;
1730       }
1731
1732       char buf[128];
1733       signal_printf("%s[%d]:  decodeEvent got %s, returning %d\n", FILE__, __LINE__, ev.sprint_event(buf), updated_events);
1734    }
1735    return true;
1736 }
1737
1738 std::string process::tryToFindExecutable(const std::string &iprogpath, int pid) 
1739 {
1740    char buffer[2];
1741    int result;
1742    // This is called by exec, so we might have a valid file path. If so,
1743    // use it... otherwise go to /proc. Helps with exec aliasing problems.
1744    buffer[0] = buffer[1] = '\0';
1745    if (iprogpath.c_str()) {
1746        int filedes = open(iprogpath.c_str(), O_RDONLY);
1747        if (filedes != -1) {
1748           result = read(filedes, buffer, 2);
1749           P_close(filedes);
1750           if (result != -1 && (buffer[0] != '#' || buffer[1] != '!')) {
1751              return iprogpath;
1752           }
1753        }
1754    }
1755
1756   // We need to dereference the /proc link.
1757   // Case 1: multiple copies of the same file opened with multiple
1758   // pids will not match (and should)
1759   // Case 2: an exec'ed program will have the same /proc path,
1760   // but different program paths
1761   std::string procpath = std::string("/proc/") + utos(pid) + std::string("/object/a.out");
1762
1763   // Sure would be nice if we could get the original....
1764   
1765   return procpath;
1766 }
1767