BPatch functions that block are now locked (on a finer grain than the rest of the...
[dyninst.git] / dyninstAPI / src / aix-ptrace.C
1 /*
2  * Copyright (c) 1996-2004 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  * This license is for research uses.  For such uses, there is no
12  * charge. We define "research use" to mean you may freely use it
13  * inside your organization for whatever purposes you see fit. But you
14  * may not re-distribute Paradyn or parts of Paradyn, in any form
15  * source or binary (including derivatives), electronic or otherwise,
16  * to any other organization or entity without our permission.
17  * 
18  * (for other uses, please contact us at paradyn@cs.wisc.edu)
19  * 
20  * All warranties, including without limitation, any warranty of
21  * merchantability or fitness for a particular purpose, are hereby
22  * excluded
23  * 
24  * By your use of Paradyn, you understand and agree that we (or any
25  * other person or entity with proprietary rights in Paradyn) are
26  * under no obligation to provide either maintenance services,
27  * update services, notices of latent defects, or correction of
28  * defects for Paradyn.
29  * 
30  * Even if advised of the possibility of such damages, under no
31  * circumstances shall we (or any other person or entity with
32  * proprietary rights in the software licensed hereunder) be liable
33  * to you or any third party for direct, indirect, or consequential
34  * damages of any character regardless of type of action, including,
35  * without limitation, loss of profits, loss of use, loss of good
36  * will, or computer failure or malfunction.  You agree to indemnify
37  * us (and any other person or entity with proprietary rights in the
38  * software licensed hereunder) for any and all liability it may
39  * incur to third parties resulting from your use of Paradyn.
40  */
41
42 // $Id: aix-ptrace.C,v 1.25 2005/02/25 07:04:46 jaw Exp $
43
44 #include <pthread.h>
45 #include "common/h/headers.h"
46 #include "dyninstAPI/src/os.h"
47 #include "dyninstAPI/src/signalhandler.h"
48 #include "dyninstAPI/src/process.h"
49 #include "dyninstAPI/src/dyn_lwp.h"
50 #include "dyninstAPI/src/dyn_thread.h"
51 #include "dyninstAPI/src/symtab.h"
52 #include "dyninstAPI/src/stats.h"
53 #include "common/h/Types.h"
54 #include "common/h/Dictionary.h"
55 #include "dyninstAPI/src/Object.h"
56 #include "common/h/pathName.h"
57 #include "dyninstAPI/src/instPoint.h"
58 #include "dyninstAPI/src/instP.h"
59 #include "dyninstAPI/src/inst-power.h" // Tramp constants
60
61 #include <procinfo.h>
62 #include <sys/ptrace.h>
63
64 #include <sys/ioctl.h>
65 #include <sys/types.h>
66 #include <fcntl.h>
67 #include <assert.h>
68 #include <stdlib.h>
69 #include <fcntl.h>
70 #include <unistd.h>
71 #include <stdio.h>
72 #include <string.h>
73 #include <scnhdr.h>
74 #include <sys/time.h>
75 #include <sys/reg.h>
76 #include <sys/user.h>
77 #include <sys/wait.h>
78 #include <procinfo.h> // struct procsinfo
79 #include <sys/types.h>
80 #include <signal.h>
81
82 // Things to use for Paradyn only
83 #ifndef BPATCH_LIBRARY
84 #include "common/h/Time.h"
85 #include "common/h/timing.h"
86 #include "paradynd/src/init.h"
87 #include "paradynd/src/instReqNode.h"
88 #endif
89
90 #if defined(BPATCH_LIBRARY)
91 #include "writeBackXCOFF.h"
92 #endif
93
94 #if !defined(BPATCH_LIBRARY)
95 #ifdef USES_PMAPI
96 #include <pmapi.h>
97 #endif
98 #endif
99
100 extern void generateBreakPoint(instruction &);
101
102 const int special_register_codenums [] = {IAR, MSR, CR, LR, CTR, XER, MQ, TID, FPSCR};
103
104 /* Getprocs() should be defined in procinfo.h, but it's not */
105 extern "C" {
106     extern int getprocs(struct procsinfo *ProcessBuffer,
107                         int ProcessSize,
108                         struct fdsinfo *FileBuffer,
109                         int FileSize,
110                         pid_t *IndexPointer,
111                         int Count);
112     extern int getthrds(pid_t, struct thrdsinfo *, int, tid_t *, int);
113 }
114
115 dyn_lwp *process::createRepresentativeLWP() {
116    // don't register the representativeLWP in real_lwps since it's not a true
117    // lwp
118    representativeLWP = createFictionalLWP(0);
119    return representativeLWP;
120 }
121
122 // getActiveFrame(): populate Frame object using toplevel frame
123 Frame dyn_lwp::getActiveFrame()
124 {
125    unsigned pc, fp;
126    if (lwp_id_) { // We have a kernel thread to target. Nifty, eh?
127       struct ptsprs spr_contents;
128       bool kernel_mode = false;
129       if (P_ptrace(PTT_READ_SPRS, lwp_id_, (int *)&spr_contents, 0, 0) == -1) {
130          if (errno != EPERM) { // EPERM == thread in kernel mode, not to worry
131             bperr("----------Error getting IAR in getActiveFrame");
132             bperr( "dyn_lwp of 0x%x with lwp %d\n", (unsigned) this,
133                     lwp_id_);
134          }
135          else
136             kernel_mode = true; // This is going to be... annoying
137       }
138       pc = spr_contents.pt_iar;
139       
140       if (!kernel_mode) {
141          unsigned allRegs[64];
142          // Register 1 is the current stack pointer. It must contain
143          // a back chain to the caller's stack pointer.
144          // Note: things like the LR are stored in the "parent's" stack frame.
145          // This allows leaf functions to store the LR, even without a 
146          // stack frame.
147          if (P_ptrace(PTT_READ_GPRS, lwp_id_, (int *)allRegs, 0, 0) == -1) {
148             perror("Problem reading stack pointer in getActiveFrame");
149             return Frame();
150          }
151          fp = allRegs[1];
152       }
153       else { // We're in the kernel. Any idea how to get the (old) PC and FP?
154          struct thrdsinfo thrd_buf[1000]; // 1000 should be enough for anyone!
155          getthrds(proc_->getPid(), thrd_buf, sizeof(struct thrdsinfo), 0,1000);
156          unsigned foo = 0;
157          while (thrd_buf[foo].ti_tid != lwp_id_) foo++;
158          fp = thrd_buf[foo].ti_ustk;
159          pc = (unsigned)-1; // ???
160       }
161       
162    }
163    else { // Old behavior, pid-based. 
164       pc = P_ptrace(PT_READ_GPR, proc_->getPid(), (int *) IAR, 0, 0); // aix 4.1 likes int *
165       if (pc == (unsigned) -1) return Frame();
166       
167       fp = P_ptrace(PT_READ_GPR, proc_->getPid(), (int *) STKP, 0, 0); // aix 4.1 likes int *
168       if (fp == (unsigned) -1) return Frame();
169       
170    }
171    return Frame(pc, fp, proc_->getPid(), NULL, this, true);
172 }
173
174
175 // See sol_proc.C for /proc version
176 bool dyn_lwp::getRegisters_(struct dyn_saved_regs *regs) {
177     if (!lwp_id_) {
178         // First, the general-purpose integer registers:
179         
180         // Format of PT_READ_GPR ptrace call: -- pass the reg number (see
181         // <sys/reg.h>) as the 'addr' (3d param) -- last 2 params (4th and
182         // 5th) ignored -- returns the value, or -1 on error but this leaves
183         // the question: what if the register really did contain -1; why
184         // should that be an error?  So, we ignore what the man page says
185         // here, and instead look at 'errno' Errors: EIO --> 3d arg didn't
186         // specify a valid register (must be 0-31 or 128-136)
187         
188         errno = 0;
189         for (unsigned i=0; i < 32; i++) {
190             unsigned value = P_ptrace(PT_READ_GPR, proc_->getPid(), (void *)i, 0, 0);
191             if ((value == (unsigned) -1) && (errno)) {
192                 perror("ptrace PT_READ_GPR");
193                 cerr << "regnum was " << i << endl;
194             }
195             regs->gprs[i] = value;
196         }
197         
198         // Next, the general purpose floating point registers.
199         
200         // Format of PT_READ_FPR ptrace call: (it differs greatly from
201         // PT_READ_GPR, probably because the FPR registers are 64 bits
202         // instead of 32) -- 3d param ('address') is the location where
203         // ptrace will store the reg's value.  -- 4th param ('data')
204         // specifies the fp reg (see <sys/reg.h>) -- last param (5th) to
205         // ptrace ignored Errors: returns -1 on error EIO --> 4th arg didn't
206         // specify a valid fp register (must be 256-287) Note: don't ask me
207         // why, but apparantly a return value of -1 doesn't seem to properly
208         // indicate an error; check errno instead.
209         
210         for (unsigned i=0; i < 32; i++) {
211             double value;
212             assert(sizeof(double)==8); // make sure it's big enough!
213             
214             if ((P_ptrace(PT_READ_FPR, proc_->getPid(), &value,
215                           FPR0 + i, // see <sys/reg.h>
216                           0) == -1) && errno) {
217                 perror("ptrace PT_READ_FPR");
218                 cerr << "regnum was " << FPR0 + i << "; FPR0=" << FPR0 << endl;
219             }
220             regs->fprs[i] = value;
221         }
222         
223         // Finally, the special registers.  (See the notes on PT_READ_GPR
224         // above: pass reg # as 3d param, 4th & 5th ignored) (Only reg
225         // numbered 0-31 or 128-136 are valid) see <sys/reg.h>; FPINFO and
226         // FPSCRX are out of range, so we can't use them!
227         
228         errno = 0;
229         for (unsigned i=0; i < num_special_registers; i++) {
230             unsigned value = P_ptrace(PT_READ_GPR, proc_->getPid(), (void *)special_register_codenums[i], 0, 0);
231             if ((value == (unsigned) -1) && errno) {
232                 perror("ptrace PT_READ_GPR for a special register");
233                 cerr << "regnum was " << special_register_codenums[i] << endl;
234             }
235             regs->sprs[i] = value;
236         }
237     }
238     
239     else {
240         errno = 0;
241         if((P_ptrace(PTT_READ_GPRS, lwp_id_, (void *)regs->gprs, 0, 0) == -1)
242            && errno)
243         {
244             perror("ptrace PTT_READ_GPRS");
245             return false;
246         }
247         // Next, the general purpose floating point registers.
248         // Again, we read as a block. 
249         // ptrace(PTT_READ_FPRS, lwp, &buffer (at least 32*8=256), 0, 0);
250         
251         errno = 0;
252         if((P_ptrace(PTT_READ_FPRS, lwp_id_, (void *)regs->fprs, 0, 0) == -1)
253            && errno)
254         {
255             perror("ptrace PTT_READ_FPRS");
256             return false;
257         }
258         
259         // We get the SPRs in a special structure. We'll then copy to
260         // our buffer for later retrieval. We could save the lot, I suppose,
261         // but there's a _lot_ of extra space that is unused.
262         struct ptsprs spr_contents;
263         
264         errno = 0;
265         if((P_ptrace(PTT_READ_SPRS, lwp_id_, (void *)&spr_contents, 0, 0)== -1)
266            && errno)
267         {
268             perror("PTT_READ_SPRS");
269             return false;
270         }
271         // Now we save everything out. List: IAR, MSR, CR, LR, CTR, XER, MQ,
272         // TID, FPSCR
273         regs->sprs[0] = spr_contents.pt_iar;
274         regs->sprs[1] = spr_contents.pt_msr;
275         regs->sprs[2] = spr_contents.pt_cr;
276         regs->sprs[3] = spr_contents.pt_lr;
277         regs->sprs[4] = spr_contents.pt_ctr;
278         regs->sprs[5] = spr_contents.pt_xer;
279         regs->sprs[6] = spr_contents.pt_mq;
280         regs->sprs[7] = spr_contents.pt_reserved_0; // Match for TID, whatever that is
281         regs->sprs[8] = spr_contents.pt_fpscr;
282     }
283     return true;
284 }
285
286
287
288 bool dyn_lwp::restoreRegisters_(const struct dyn_saved_regs &regs) {
289    if (!lwp_id_) {
290       // First, the general-purpose registers:
291       // Format for PT_WRITE_GPR:
292       // 3d param ('address'): specifies the register (must be 0-31 or 128-136)
293       // 4th param ('data'): specifies value to store
294       // 5th param ignored.
295       // Returns 3d param on success else -1 on error.
296       // Errors:
297       //    EIO: address must be 0-31 or 128-136
298       // How's this for fun: ptrace returns the value the register is set
299       // to. If this happens to be -1, we interpret it as failure (because -1
300       // means failure). In this case, check the value of errno. But errno
301       // gets set on failure, not success... so we need to manually reset it.
302
303       errno = 0;
304       for (unsigned i=0; i < 32; i++) {
305          if (P_ptrace(PT_WRITE_GPR, proc_->getPid(), (int *)i, regs.gprs[i], 0)
306              == -1)
307          {
308             if (errno) {
309                perror("restoreRegisters PT_WRITE_GPR");
310                return false;
311             }
312          }
313       } 
314       
315       // Next, the floating-point registers:
316       // Format of PT_WRITE_FPR: (it differs from PT_WRITE_GPR, probably
317       // because FP registers are 8 bytes instead of 4)
318       // 3d param ('address'): address of the value to store
319       // 4th param ('data'): reg num (256-287)
320       // 5th param ignored
321       // returns -1 on error
322       // Errors:
323       //    EIO: reg num must be 256-287
324       
325       for (unsigned i=FPR0; i <= FPR31; i++) {
326          if (P_ptrace(PT_WRITE_FPR, proc_->getPid(),
327                       (void *)&(regs.fprs[i-FPR0]), i, 0) == -1) {
328             if (errno) {
329                perror("ptrace PT_WRITE_FPR");
330                cerr << "regnum was " << i << endl;
331                return false;
332             }
333          }
334       } 
335       
336       // Finally, special registers:
337       
338       for (unsigned i=0; i < num_special_registers; i++) {
339          if (P_ptrace(PT_WRITE_GPR, proc_->getPid(), 
340                       (void *)(special_register_codenums[i]), 
341                       regs.sprs[i], 0) == -1) {
342             if (errno) {
343                perror("ptrace PT_WRITE_GPR for a special register");
344                cerr << "regnum was " << special_register_codenums[i] << endl;
345                return false;
346             }
347          }
348       }
349    }
350    else {
351       if (P_ptrace(PTT_WRITE_GPRS, lwp_id_, (void *)regs.gprs, 0, 0) == -1) {
352          perror("ptrace PTT_WRITE_GPRS");
353          return false;
354       }
355       // Next, the general purpose floating point registers.
356       // ptrace(PTT_WRITE_FPRS, lwp, &buffer (at least 32*8=256), 0, 0);
357       if (P_ptrace(PTT_WRITE_FPRS, lwp_id_, (void *)regs.fprs, 0, 0) == -1) {
358          perror("ptrace PTT_WRITE_FPRS");
359          return false;
360       }
361       
362       // We get the SPRs in a special structure. We'll then copy to
363       // our buffer for later retrieval. We could save the lot, I suppose,
364       // but there's a _lot_ of extra space that is unused.
365       struct ptsprs saved_sprs;
366       struct ptsprs current_sprs;
367       // Restore. List: IAR, MSR, CR, LR, CTR, XER, MQ, TID, FPSCR
368       ptrace(PTT_READ_SPRS, lwp_id_, (int *)&current_sprs, 0, 0);
369       
370       saved_sprs.pt_iar = regs.sprs[0];
371       saved_sprs.pt_msr = regs.sprs[1];
372       saved_sprs.pt_cr = regs.sprs[2];
373       saved_sprs.pt_lr = regs.sprs[3];
374       saved_sprs.pt_ctr = regs.sprs[4];
375       saved_sprs.pt_xer = regs.sprs[5];
376       saved_sprs.pt_mq = regs.sprs[6];
377       saved_sprs.pt_reserved_0 = regs.sprs[7];
378       saved_sprs.pt_fpscr = regs.sprs[8];
379       
380       if (P_ptrace(PTT_WRITE_SPRS, lwp_id_, (void *)&saved_sprs, 0, 0) == -1) {
381          perror("PTT_WRITE_SPRS");
382          return false;
383       }
384    }
385    return true;
386 }
387
388 bool dyn_lwp::changePC(Address loc, struct dyn_saved_regs *)
389 {
390    if (!lwp_id_) {
391       if ( !P_ptrace(PT_READ_GPR, proc_->getPid(), (void *)IAR, 0, 0)) {
392          perror("changePC (PT_READ_GPR) failed");
393          return false;
394       }
395       
396       
397       if (P_ptrace(PT_WRITE_GPR, proc_->getPid(), (void *)IAR, loc, 0) == -1) {
398          perror("changePC (PT_WRITE_GPR) failed");
399          return false;
400       }
401       
402       // Double-check that the change was made by reading the IAR register
403       if (P_ptrace(PT_READ_GPR, proc_->getPid(), (void *)IAR, 0,0) != (int)loc)
404       {
405          perror("changePC (verify) failed");
406          return false;
407       }
408    }
409    else {
410       struct ptsprs spr_contents;
411       if (P_ptrace(PTT_READ_SPRS, lwp_id_, (void *)&spr_contents, 0,0) == -1) {
412          perror("changePC: PTT_READ_SPRS failed");
413          return false;
414       }
415       spr_contents.pt_iar = loc;
416       // Write the registers back in
417       
418       if (P_ptrace(PTT_WRITE_SPRS, lwp_id_, (void *)&spr_contents, 0, 0) == -1)
419       {
420          perror("changePC: PTT_WRITE_SPRS failed");
421          return false;
422       }
423       // Double check...
424       struct ptsprs spr_doublecheck;
425
426       if (P_ptrace(PTT_READ_SPRS, lwp_id_, (void *)&spr_doublecheck, 0,0) == -1) {
427          perror("changePC: PTT_READ_SPRS failed");
428          return false;
429       }
430       if (spr_doublecheck.pt_iar != loc) {
431           bperr( "Doublecheck failed! PC at 0x%x instead of 0x%x!\n",
432                   (int)spr_doublecheck.pt_iar, (int)loc);
433       }
434       
435    }
436    return true;
437 }
438
439
440 unsigned recognize_thread(process *proc, unsigned lwp_id) {
441    dyn_lwp *lwp = proc->getLWP(lwp_id);
442
443    pdvector<AstNode *> ast_args;
444    AstNode *ast = new AstNode("DYNINSTregister_running_thread", ast_args);
445
446    return proc->getRpcMgr()->postRPCtoDo(ast, true, NULL, (void *)lwp_id,
447                                          true, NULL, lwp);
448 }
449
450 unsigned get_childproc_lwp(process *proc) {
451    pdvector<unsigned> lwpid_buf;
452    tid_t indexPtr = 0;   
453    struct thrdsinfo thrd_info;
454    int found_lwp = -1;
455    int num_found = 0;
456    do {
457       num_found = getthrds(proc->getPid(), &thrd_info,
458                            sizeof(struct thrdsinfo), &indexPtr, 1);
459       //cerr << "called getthrds, ret: " << num_found << ", indexPtr: "
460       //     << indexPtr << ", tid; " << thrd_info.ti_tid << endl;
461       if(found_lwp == -1)
462          found_lwp = thrd_info.ti_tid;
463       else if(num_found > 0) {
464          // this warning shouldn't occur because on pthreads only the thread
465          // which initiated the fork should be duplicated in the child process
466          cerr << "warning, multiple threads found in child process when "
467               << "only one thread is expected\n";
468       }
469    } while(num_found > 0);
470
471    return static_cast<unsigned>(found_lwp);
472 }
473
474
475 // run rpcs on each lwp in the child process that will start the virtual
476 // timer of each thread and cause the rtinst library to notify the daemon of
477 // a new thread.  For pthreads though, which AIX uses, there should only be
478 // one thread in the child process (ie. the thread which initiated the fork).
479
480 void process::recognize_threads(pdvector<unsigned> *completed_lwps) {
481    unsigned found_lwp = get_childproc_lwp(this);
482    //cerr << "chosen lwp = " << found_lwp << endl;
483
484    unsigned rpc_id = recognize_thread(this, found_lwp);
485    bool cancelled = false;
486
487    do {
488        getRpcMgr()->launchRPCs(false);
489        if(hasExited())
490            return;
491        getSH()->checkForAndHandleProcessEvents(false);
492        
493        irpcState_t rpc_state = getRpcMgr()->getRPCState(rpc_id);
494        if(rpc_state == irpcWaitingForSignal) {
495            //cerr << "rpc_id: " << rpc_id << " is in syscall, cancelling rpc\n";
496            getRpcMgr()->cancelRPC(rpc_id);
497            cancelled = true;
498            break;
499        }
500    } while(getRpcMgr()->getRPCState(rpc_id) != irpcNotValid); // Loop rpc is done
501    
502    if(! cancelled) {
503       (*completed_lwps).push_back(found_lwp);
504    }
505 }
506
507
508 /*
509 static bool executeDummyTrap(process *theProc) {
510    assert(theProc->status() == stopped);
511    
512    // Allocate a tempTramp. Assume there is text heap space available,
513    // since otherwise we're up a creek.
514    unsigned tempTramp = theProc->inferiorMalloc(8, textHeap);
515    assert(tempTramp);
516
517    unsigned theInsns[2];
518    theInsns[0] = BREAK_POINT_INSN;
519    theInsns[1] = 0; // illegal insn, just to make sure we never exec past the trap
520    if (!theProc->writeTextSpace((void *)tempTramp, sizeof(theInsns), &theInsns)) {
521       cerr << "executeDummyTrap failed because writeTextSpace failed" << endl;
522       return false;
523    }
524
525    
526    unsigned oldpc = P_ptrace(PT_READ_GPR, theProc->getPid(), (void *)IAR, 0, 0);
527    if (oldpc == (unsigned) -1) return false;
528    
529    if (P_ptrace(PT_WRITE_GPR, theProc->getPid(), (void *)IAR, tempTramp, 0) == -1)
530      return false;
531
532    if ((unsigned)P_ptrace(PT_READ_GPR, theProc->getPid(), (void *)IAR, 0, 0) != tempTramp) {
533       cerr << "executeDummyTrap failed because PT_READ_GPR of IAR register failed" << endl;
534       return false;
535    }
536
537    // We bypass continueProc() because continueProc() changes theProc->status_, which
538    // we don't want to do here
539    
540    P_ptrace(PT_CONTINUE, theProc->getPid(), (void *)1, 0, 0);
541       // what if there are any pending signals?  Don't we lose the chance to forward
542       // them now?
543    assert(errno == 0);
544
545    // Restore the old PC register value
546    
547    P_ptrace(PT_WRITE_GPR, theProc->getPid(), (void *)IAR, oldpc, 0);
548    assert(errno == 0);
549
550    // delete the temp tramp now (not yet implemented)
551
552 #ifdef INFERIOR_RPC_DEBUG
553    cerr << "leaving executeDummyTrap now" << endl;
554    cerr.flush();
555 #endif
556
557    return true;
558 }
559 */
560
561 bool dyn_lwp::executingSystemCall() 
562 {
563   // lwp -- we may care about a particular thread.
564   errno = 0;
565   int retCode = 0;
566   if (lwp_id_) {
567     // Easiest way to check: try to read GPRs and see
568     // if we get EPERM back
569       struct ptsprs spr_contents;
570       P_ptrace(PTT_READ_SPRS, lwp_id_, (int *)&spr_contents, 0, 0); // aix 4.1 likes int *
571   }
572   else {
573       // aix 4.1 likes int *
574       retCode = P_ptrace(PT_READ_GPR, proc_->getPid(), (int *) IAR, 0, 0); 
575   }
576   
577   if (errno == EPERM) {
578       return true;
579   }
580   
581   return false;
582 }
583
584 bool attach_helper(process *proc) {
585    // formerly OS::osAttach()    
586
587    int ret = ptrace(PT_ATTACH, proc->getPid(), (int *)0, 0, 0);
588    if (ret == -1)
589       ret = ptrace(PT_REATT, proc->getPid(), (int *)0, 0, 0);
590
591    return (ret != -1);
592 }
593
594 bool dyn_lwp::deliverPtrace(int request, void *addr, int data, void *addr2) {
595    bool needToCont = false;
596    bool ret;
597   
598    if(request != PT_DETACH && status() == running) {
599       if(pauseLWP() == true)
600          needToCont = true;
601    }
602
603    // aix 4.1 likes int *
604    if (ptrace(request, getPid(), (int *)addr, data, (int *)addr2) == -1) 
605       ret = false;
606    else
607       ret = true;
608
609    if(request != PT_DETACH && needToCont==true)
610       continueLWP();
611
612    return ret;
613 }
614
615
616 bool dyn_lwp::stop_() {
617    assert(this == proc_->getRepresentativeLWP());
618    /* Choose either one of the following methods for stopping a process, 
619     * but not both. 
620     * The choice must be consistent with that in process::continueProc_ 
621     * and ptraceKludge::continueProcess
622     */
623         return (P_kill(getPid(), SIGSTOP) != -1); 
624 }
625
626 void OS::osTraceMe(void)
627 {
628   int ret;
629   ret = ptrace(PT_TRACE_ME, 0, 0, 0, 0);
630   assert(ret != -1);
631 }
632
633 bool process::isRunning_() const {
634    // determine if a process is running by doing low-level system checks, as
635    // opposed to checking the 'status_' member vrble.  May assume that attach()
636    // has run, but can't assume anything else.
637
638   // Here's the plan: use getprocs() to get process info.
639   // Constant for the number of processes wanted in info
640   const unsigned int numProcsWanted = 1;
641   struct procsinfo procInfoBuf[numProcsWanted];
642   struct fdsinfo fdsInfoBuf[numProcsWanted];
643   int numProcsReturned;
644   // The pid sent to getProcs() is modified, so make a copy
645   pid_t wantedPid = pid; 
646   // We really don't need to recalculate the size of the structures
647   // every call through here. The compiler should optimize these
648   // to constants.
649   const int sizeProcInfo = sizeof(struct procsinfo);
650   const int sizeFdsInfo = sizeof(struct fdsinfo);
651
652   numProcsReturned = getprocs(procInfoBuf,
653                               sizeProcInfo,
654                               fdsInfoBuf,
655                               sizeFdsInfo,
656                               &wantedPid,
657                               numProcsWanted);
658
659   if (numProcsReturned == -1) // We have an error
660     perror("Failure in isRunning_");
661
662   // This is list of possible values for pi_state (from sys/proc.h)
663   //#define SNONE           0               /* slot is available    */
664   //#define SIDL            4               /* process is created   */
665   //#define SZOMB           5               /* process is dying     */ 
666   //#define SSTOP           6               /* process is stopped   */
667   //#define SACTIVE         7               /* process is active    */
668   //#define SSWAP           8               /* process is swapped   */
669   // We use SACTIVE
670
671   return (procInfoBuf[0].pi_state == SACTIVE);
672 }
673
674 // TODO is this safe here ?
675 bool dyn_lwp::continueLWP_(int signalToContinueWith) {
676    // has to be representative LWP
677    assert(this == proc_->getRepresentativeLWP());
678
679    // we don't want to operate on the process in this state
680    ptraceOps++; 
681    ptraceOtherOps++;
682
683    int arg4 = 0;
684    if(signalToContinueWith != dyn_lwp::NoSignal) {
685       arg4 = signalToContinueWith;
686    }
687
688    bool ret;
689    // aix 4.1 likes int *
690    if( ptrace(PT_CONTINUE, getPid(), (int *)1, arg4, (int *)NULL) == -1)
691       ret = false;
692    else
693       ret = true;
694
695    return ret;
696 }
697
698 terminateProcStatus_t process::terminateProc_()
699 {
700    if (P_ptrace(PT_KILL, pid, NULL, 0, NULL) != 0) {
701       // For some unknown reason, the above ptrace sometimes fails with a "no
702       // such process" error, even when there is such a process and the process
703       // is runnable.  So, if the above fails, we try killing it another way.
704      if (kill(pid, SIGKILL) != 0) {
705        if (errno == ESRCH)
706          return alreadyTerminated;
707        else
708          return terminateFailed;
709      }
710      return terminateSucceeded;
711 }
712
713 void dyn_lwp::realLWP_detach_() {
714    assert(is_attached());  // dyn_lwp::detach() shouldn't call us otherwise
715 }
716
717 void dyn_lwp::representativeLWP_detach_() {
718    assert(is_attached());  // dyn_lwp::detach() shouldn't call us otherwise
719    if(! proc_->isAttached()) return;
720
721    ptraceOps++; ptraceOtherOps++;
722    if(! deliverPtrace(PT_DETACH, (char*)1, SIGSTOP, NULL)) {
723       sprintf(errorLine, "Unable to detach %d\n", getPid());
724       logLine(errorLine);
725       showErrorCallback(40, (const char *) errorLine);
726    }
727
728    // always return true since we report the error condition.
729    return;
730 }
731
732 bool process::API_detach_(const bool cont) {
733   if (!isAttached())
734       return false;
735
736   ptraceOps++; ptraceOtherOps++;
737   return getRepresentativeLWP()->deliverPtrace(PT_DETACH,(char*)1,
738                                                cont ? 0 : SIGSTOP, NULL);
739 }
740
741 // temporarily unimplemented, PT_DUMPCORE is specific to sunos4.1
742 bool process::dumpCore_(const pdstring coreFile) {
743   if (!isAttached()) 
744     return false;
745   ptraceOps++; ptraceOtherOps++;
746
747   if (!dumpImage(coreFile)) {
748      assert(false);
749   }
750
751   (void) ptrace(PT_CONTINUE, pid, (int*)1, SIGBUS, NULL);
752   return true;
753 }
754
755 bool dyn_lwp::writeTextWord(caddr_t inTraced, int data) {
756    ptraceBytes += sizeof(int); ptraceOps++;
757    return deliverPtrace(PT_WRITE_I, inTraced, data, NULL);
758 }
759
760 bool dyn_lwp::writeTextSpace(void *inTraced, u_int amount, const void *inSelf)
761 {
762   return writeDataSpace(inTraced, amount, inSelf);
763 }
764
765 bool dyn_lwp::readTextSpace(void *inTraced, u_int amount, const void *inSelf) {
766   return readDataSpace(inTraced, amount, const_cast<void *>(inSelf));
767 }
768
769 /* Note:
770  * Writes are not forced to be synchronous with instruction fetch on the
771  * PowerPC architecture. So this means that if we write to memory and then
772  * try to execute those instructions, our writes may not have propagated
773  * through. I've seen this happen with inferiorRPCs, and occasionally with
774  * base/mini tramps, though less often. So we're going to explicitly
775  * flush. Ref: PowerPC architecture, "PowerPC virtual environment arch",
776  * p344
777  *
778  * Update: there is an OS fix for this.
779  */
780 bool dyn_lwp::writeDataSpace(void *inTraced, u_int amount, const void *inSelf)
781 {
782    ptraceBytes += amount;
783   
784    while (amount > 1024) {
785       ptraceOps++;
786       if(! deliverPtrace(PT_WRITE_BLOCK, inTraced, 1024,
787                          const_cast<void*>(inSelf)))
788       {
789          perror("Failed write");
790          return false;
791       }
792       amount -= 1024;
793       inTraced = (char *)inTraced + 1024;
794       inSelf = (char *)const_cast<void*>(inSelf) + 1024;
795    }
796
797    ptraceOps++;
798
799    if(! deliverPtrace(PT_WRITE_BLOCK, inTraced, amount,
800                       const_cast<void*>(inSelf)))
801    {
802       bperr( "Write of %d bytes from 0x%x to 0x%x\n",
803               amount, (int)inSelf, (int)inTraced);
804       while(1);
805       
806     return false;
807    }
808    return true;
809 }
810
811 bool dyn_lwp::readDataSpace(const void *inTraced, u_int amount, void *inSelf)
812 {
813    ptraceBytes += amount;
814
815    while (amount > 1024) {
816       ptraceOps++;
817
818       if(!deliverPtrace(PT_READ_BLOCK,const_cast<void*>(inTraced),
819                         1024, inSelf))
820          return false;
821
822       amount -= 1024;
823       inTraced = (const char *)inTraced + 1024;
824       inSelf = (char *)inSelf + 1024;
825    }
826
827    ptraceOps++;
828    return deliverPtrace(PT_READ_BLOCK, const_cast<void*>(inTraced),
829                         amount, inSelf);
830 }
831
832 // Can this be unified with linux' version?
833 // Maybe, but it can be unified with decodeProcessEvent
834 // if we add a "pid" parameter to decodeProcessEvent. 
835 bool dyn_lwp::waitUntilStopped() {
836   /* make sure the process is stopped in the eyes of ptrace */
837    bool isStopped = false;
838    int loops = 0;
839    while (!isStopped) {
840       if(proc_->hasExited()) return false;
841       if (loops == 2000) {
842          // Resend sigstop...
843          if(proc_->multithread_capable()) {
844             // We see the process stopped, but we think it is running
845             // Check to see if the process is stopped, and if so set status
846             struct procsinfo procInfoBuf;
847             const int procsinfoSize = sizeof(struct procsinfo);
848             struct fdsinfo fdsInfoBuf;
849             const int fdsinfoSize = sizeof(struct fdsinfo);
850             int pidVar = getPid();
851             int numProcs = getprocs(&procInfoBuf,
852                                     procsinfoSize,
853                                     &fdsInfoBuf,
854                                     fdsinfoSize,
855                                     &pidVar,
856                                     1);
857             if (numProcs == 1) {
858                if (procInfoBuf.pi_state == SSTOP) {
859                   proc_->set_status(stopped);
860                   return true;
861                }
862             }
863          }
864          stop_();
865          loops = 0;
866       }
867
868       pdvector<procevent *> foundEvents;      
869       int timeout = 0;
870       bool gotEvent = getSH()->checkForProcessEvents(&foundEvents, getPid(),
871                                                      timout);
872       procevent *ev = NULL;
873       if(gotEvent) {
874          if(foundEvents.size()) {
875             assert(foundEvents.size() == 1);
876             ev = foundEvents[0];
877          }
878          assert(proc_ == ev->proc);
879       } else {      
880          loops++;
881          usleep(10);
882          continue;
883       }      
884
885       if (didProcReceiveSignal(ev->why) && ev->what == SIGSTOP) {
886          isStopped = true;
887       }
888       else {
889          if(!getSH()->handleProcessEvent(*ev))
890             bperr( "handleProcessEvent failed!\n");
891          delete ev;
892          // if handleProcessEvent left the proc stopped, continue
893          // it so we that we will get the SIGSTOP signal we sent the proc
894          if(proc_->status() == stopped) {
895             proc_->continueProc();
896          }
897          loops = 0;
898       }
899    }
900    return true;
901 }
902
903 //
904 // Write out the current contents of the text segment to disk.  This is useful
905 //    for debugging dyninst.
906 //
907 bool process::dumpImage(pdstring outFile) {
908     // formerly OS::osDumpImage()
909     const pdstring &imageFileName = symbols->file();
910     // const Address codeOff = symbols->codeOffset();
911     int i;
912     int rd;
913     int ifd;
914     int ofd;
915     int cnt;
916     int ret;
917     int total;
918     int length;
919     Address baseAddr;
920 #if !defined(_THREAD_SAFE) || !defined(_THREAD_SAFE_ERRNO)
921     // extern int errno;
922 #endif
923     char buffer[4096];
924     struct filehdr hdr;
925     struct stat statBuf;
926     struct aouthdr aout;
927     struct scnhdr *sectHdr;
928     bool needsCont = false;
929     struct ld_info info[64];
930 #ifdef notdef
931     // Added 19JAN01, various debug items
932     // Get the kernel thread ID for the currently running
933     // process
934     struct thrdsinfo thrd_buf[10]; // max 10 threads
935     int num_thrds = getthrds(pid, thrd_buf, sizeof(struct thrdsinfo),
936                              0, 1);
937     if (num_thrds == -1) {
938         bperr( "%d ", errno);
939       bperr("getting TID");
940     }
941     else
942       bperr( "%d threads currently running\n", num_thrds);
943     int kernel_thread = thrd_buf[0].ti_tid;
944     int gpr_contents[32];
945     ptrace(PTT_READ_GPRS, kernel_thread,
946            gpr_contents, 0, 0);
947     bperr( "Register contents:\n");
948     for (i = 0; i < 32; i++)
949       bperr( "%d: %x\n", i, gpr_contents[i]);
950     
951     struct ptsprs spr_contents;
952     ptrace(PTT_READ_SPRS, kernel_thread,
953            (int *)&spr_contents, 0, 0);
954     
955     bperr( "IAR: %x\n", spr_contents.pt_iar);
956     bperr( "LR: %x\n", spr_contents.pt_lr);
957     bperr( "CR: %x\n", spr_contents.pt_cr);
958     bperr( "CTR: %x\n", spr_contents.pt_ctr);
959     bperr( "MSR: %x\n", spr_contents.pt_msr);
960
961     // And get and print the chunk of memory around the error
962     int memory[32];
963     ptrace(PT_READ_BLOCK, pid, (int *)spr_contents.pt_iar-64,
964            4*32, memory);
965     for (i = 0; i < 32; i++) {
966       fprintf(stderr, "%x ", (spr_contents.pt_iar-64) + i*4);
967       decodeInstr(memory[i]);
968     }
969
970 #endif
971
972     ifd = open(imageFileName.c_str(), O_RDONLY, 0);
973     if (ifd < 0) {
974       sprintf(errorLine, "Unable to open %s\n", imageFileName.c_str());
975       logLine(errorLine);
976       showErrorCallback(41, (const char *) errorLine);
977       perror("open");
978       return true;
979     }
980
981     rd = fstat(ifd, &statBuf);
982     if (rd != 0) {
983       perror("fstat");
984       sprintf(errorLine, "Unable to stat %s\n", imageFileName.c_str());
985       logLine(errorLine);
986       showErrorCallback(72, (const char *) errorLine);
987       return true;
988     }
989     length = statBuf.st_size;
990     ofd = open(outFile.c_str(), O_WRONLY|O_CREAT, 0777);
991     if (ofd < 0) {
992       perror("open");
993       exit(-1);
994     }
995
996     /* read header and section headers */
997     cnt = read(ifd, &hdr, sizeof(struct filehdr));
998     if (cnt != sizeof(struct filehdr)) {
999         sprintf(errorLine, "Error reading header\n");
1000         logLine(errorLine);
1001         showErrorCallback(44, (const char *) errorLine);
1002         return false;
1003     }
1004
1005     cnt = read(ifd, &aout, sizeof(struct aouthdr));
1006
1007     sectHdr = (struct scnhdr *) calloc(sizeof(struct scnhdr), hdr.f_nscns);
1008     cnt = read(ifd, sectHdr, sizeof(struct scnhdr) * hdr.f_nscns);
1009     if ((unsigned) cnt != sizeof(struct scnhdr)* hdr.f_nscns) {
1010         sprintf(errorLine, "Section headers\n");
1011         logLine(errorLine);
1012         return false;
1013     }
1014
1015     /* now copy the entire file */
1016     lseek(ofd, 0, SEEK_SET);
1017     lseek(ifd, 0, SEEK_SET);
1018     for (i=0; i < length; i += 4096) {
1019         rd = read(ifd, buffer, 4096);
1020         write(ofd, buffer, rd);
1021         total += rd;
1022     }
1023
1024     if (!stopped) {
1025         // make sure it is stopped.
1026         process::findProcess(pid)->getRepresentativeLWP()->stop_();
1027
1028         waitpid(pid, NULL, WUNTRACED);
1029         needsCont = true;
1030     }
1031
1032     ret = ptrace(PT_LDINFO, pid, (int *) &info, sizeof(info), (int *) &info);
1033     if (ret != 0) {
1034         statusLine("Unable to get loader info about process");
1035         showErrorCallback(43, "Unable to get loader info about process");
1036         return false;
1037     }
1038
1039     baseAddr = (unsigned)info[0].ldinfo_textorg + (unsigned)aout.text_start;
1040     sprintf(errorLine, "seeking to %ld as the offset of the text segment \n",
1041         aout.text_start);
1042     logLine(errorLine);
1043     sprintf(errorLine, "Code offset = 0x%lx\n", baseAddr);
1044     logLine(errorLine);
1045
1046     /* seek to the text segment */
1047     lseek(ofd, aout.text_start, SEEK_SET);
1048     for (i=0; i < aout.tsize; i+= 1024) {
1049         length = ((i + 1024) < aout.tsize) ? 1024 : aout.tsize -i;
1050         if (ptrace(PT_READ_BLOCK, pid, (int*) (baseAddr + i), length, (int *)buffer) == -1) {
1051           perror("ptrace");
1052           assert(0);
1053         }
1054         write(ofd, buffer, length);
1055     }
1056
1057     if (needsCont) {
1058        ptrace(PT_CONTINUE, pid, (int*) 1, SIGCONT, 0);
1059     }
1060
1061     close(ofd);
1062     close(ifd);
1063
1064     return true;
1065 }
1066
1067 // Returns all information necessary to get and parse the executable
1068 // file.
1069 // We also do some other one-time setup here. It should probably go somewhere
1070 // else.
1071 // Returns something of type fileDescriptor
1072 // Take a file name, since we might not be using member file
1073 fileDescriptor *getExecFileDescriptor(pdstring filename,
1074                                       int &status, 
1075                                       bool waitForTrap)
1076 {
1077     int ret;
1078     // Sneak the pid out of the status word, since it's only overwritten
1079     // anyway
1080     int pid = status; 
1081     struct ld_info *ptr;
1082     // Credit where credit is due: it works in GDB 5.0, so it should
1083     // work here. Right? Of course it will. NOT!
1084     // It's impossible to a priori know how many ld_info records there
1085     // will be for an executable, so we guess n < 1024
1086     ptr = (struct ld_info *) malloc (1024*sizeof(struct ld_info));
1087
1088     // wait for the TRAP point.
1089     if (waitForTrap)
1090       waitpid(pid, &status, WUNTRACED);
1091
1092     status = WSTOPSIG(status);
1093
1094     /* It seems that AIX has some timing problems and
1095      when the user stack grows, the kernel doesn't update the stack info in time
1096      and ptrace calls step on user stack. This is the reason why call sleep 
1097      here, giving the kernel some time to update its internals. */
1098     // Is this still around? How do you tell?
1099     usleep (36000);
1100
1101     ret = ptrace(PT_LDINFO, pid, 
1102                  (int *) ptr, 1024 * sizeof(struct ld_info), (int *)ptr);
1103
1104     if (ret != 0) {
1105        // Two possible problems here -- one, the process didn't exist. We
1106        // need to handle this. Second, we haven't attached yet. Work around
1107        if (0) { // Proc doesn't exist
1108           return NULL;
1109        }
1110        else {
1111           ptr->ldinfo_textorg = (void *) -1; // illegal flag value
1112           ptr->ldinfo_dataorg = (void *) -1; // illegal flag value
1113           // attempt to continue and patch up later
1114        }        
1115        /*
1116          perror("failed to get loader information about process");
1117          statusLine("Unable to get loader info about process, application aborted");
1118          showErrorCallback(43, "Unable to get loader info about process, application aborted");
1119          return NULL;
1120        */
1121     }
1122
1123     // Set up and return the file descriptor. In this case we actually
1124     // return a fileDescriptor_AIX type (text/data org value, pid)
1125     pdstring member = "";
1126     Address text_org = (Address) ptr->ldinfo_textorg;
1127     Address data_org = (Address) ptr->ldinfo_dataorg;
1128
1129     fileDescriptor *desc = 
1130       (fileDescriptor *) new fileDescriptor_AIX(filename, member, text_org,
1131                                                 data_org, pid, true);
1132
1133     return desc;
1134 }
1135
1136 Address dyn_lwp::readRegister(Register returnValReg) 
1137 {
1138   if (lwp_id_) {
1139       unsigned allRegs[64];
1140       P_ptrace(PTT_READ_GPRS, lwp_id_, (int *)allRegs, 0, 0); // aix 4.1 likes int *
1141       return allRegs[returnValReg];
1142   }
1143   else
1144     return P_ptrace(PT_READ_GPR, proc_->getPid(), (void *)returnValReg, 0, 0);
1145 }
1146
1147 syscallTrap *process::trapSyscallExitInternal(Address syscall) {
1148     syscallTrap *trappedSyscall = NULL;
1149
1150     // HACK for catchup only
1151     if (syscall == 0) return NULL;
1152     
1153     for (unsigned iter = 0; iter < syscallTraps_.size(); iter++) {
1154         if (syscallTraps_[iter]->syscall_id == syscall) {
1155             trappedSyscall = syscallTraps_[iter];
1156             break;
1157         }
1158     }
1159     if (trappedSyscall) {
1160         trappedSyscall->refcount++;
1161         return trappedSyscall;
1162     }
1163     else {
1164         // Add a trap at this address, please
1165         trappedSyscall = new syscallTrap;
1166         trappedSyscall->refcount = 1;
1167         trappedSyscall->syscall_id = syscall;
1168         readDataSpace( (void*)syscall, sizeof(instruction), trappedSyscall->saved_insn, true);
1169
1170         instruction insnTrap;
1171         generateBreakPoint(insnTrap);
1172         writeDataSpace((void *)syscall, sizeof(instruction), &(insnTrap.raw));
1173         syscallTraps_.push_back(trappedSyscall);
1174         return trappedSyscall;
1175     }
1176     // Should never be reached
1177     return NULL;
1178 }
1179
1180 bool process::clearSyscallTrapInternal(syscallTrap *trappedSyscall) {
1181     // Decrement the reference count, and if it's 0 remove the trapped
1182     // system call
1183     assert(trappedSyscall->refcount > 0);
1184     
1185     trappedSyscall->refcount--;
1186     if (trappedSyscall->refcount > 0)
1187         return true;
1188     
1189     // Erk... we hit 0. Undo the trap
1190     if (!writeDataSpace((void *)trappedSyscall->syscall_id, sizeof(instruction),
1191                         trappedSyscall->saved_insn))
1192         return false;
1193     // Now that we've reset the original behavior, remove this
1194     // entry from the vector
1195
1196     pdvector<syscallTrap *> newSyscallTraps;
1197     for (unsigned iter = 0; iter < syscallTraps_.size(); iter++) {
1198         if (trappedSyscall != syscallTraps_[iter])
1199             newSyscallTraps.push_back(syscallTraps_[iter]);
1200     }
1201     syscallTraps_ = newSyscallTraps;
1202
1203     delete trappedSyscall;
1204     return true;
1205 }
1206
1207
1208 Address dyn_lwp::getCurrentSyscall(Address aixHACK) {
1209     // We've been given the address of a return point in the function.
1210     // Get and return the return address
1211     if (!aixHACK || aixHACK == -1) {
1212        return 0;
1213     }
1214
1215     int_function *func = proc_->findFuncByAddr(aixHACK);
1216     if (!func) {
1217         return 0;
1218     }
1219
1220     pdvector<instPoint *> funcExits = func->funcExits(proc());
1221     // Only one exit on AIX
1222     if (funcExits.size() != 1) {
1223         return 0;
1224     }
1225     
1226     trampTemplate *baseTramp = NULL;
1227     // [] operator defines if it can't find the data -- that's BAD
1228     proc()->baseMap.find(funcExits[0],baseTramp);
1229     
1230     if (!baseTramp) {
1231         // Okay... we need a base tramp to insert the breakpoint at,
1232         // but there's no base tramp there. So insert one (man, this
1233         // is getting complicated)
1234         returnInstance *retInstance = NULL;
1235         bool defer;
1236         baseTramp = findOrInstallBaseTramp(proc_,
1237                                             funcExits[0],
1238                                             retInstance,
1239                                             false,
1240                                             false,
1241                                             defer,
1242                                             true);
1243         if (!retInstance) return 0;
1244         if (!baseTramp) return 0;
1245         retInstance->installReturnInstance(proc_);
1246
1247         // But it gets worse :) since we need to fix up the return address
1248         // to go to our new tramp as well... copy code from catchup side effect
1249         // fixes
1250         pdvector<Frame> stackwalk;
1251         walkStack(stackwalk);
1252         int i = 0;
1253         while (stackwalk[i].getPC() != aixHACK) i++;
1254         
1255         // Frame won't be uppermost...
1256         Frame parentFrame = stackwalk[i].getCallerFrame();
1257         Address oldReturnAddr;
1258                 
1259         // Here's the fun bit. We actually store the LR in the parent's frame. So 
1260         // we need to backtrace a bit.
1261         proc()->readDataSpace((void *)(parentFrame.getFP()+8), sizeof(Address), &oldReturnAddr, false);
1262         
1263         if (oldReturnAddr != baseTramp->baseAddr) {
1264             // Write it into the save slot
1265             proc()->writeDataSpace((void*)(parentFrame.getFP()+8), sizeof(Address), &(baseTramp->baseAddr));
1266             proc()->writeDataSpace((void*)(parentFrame.getFP()+12), sizeof(Address), &oldReturnAddr);
1267         }
1268     }
1269     return baseTramp->baseAddr;
1270 }
1271 // Assumes we've stopped at a noop
1272 bool dyn_lwp::stepPastSyscallTrap() {
1273     Frame frame = getActiveFrame();
1274     
1275     return changePC(frame.getPC() + sizeof(instruction), NULL);
1276 }
1277
1278 int dyn_lwp::hasReachedSyscallTrap() {
1279     
1280     Frame frame = getActiveFrame();
1281     if ((int)frame.getPC() == -1)
1282         return 0;
1283     if (trappedSyscall_ && frame.getPC() == trappedSyscall_->syscall_id) {
1284         return 2;
1285     }
1286     if (proc()->checkTrappedSyscallsInternal(frame.getPC())) {
1287         return 1;
1288     }
1289     
1290     return 0;
1291 }
1292
1293 bool dyn_lwp::realLWP_attach_() {
1294    // Umm... no file descriptors on AIX
1295    return true;
1296 }
1297
1298 bool dyn_lwp::representativeLWP_attach_() {
1299    // Umm... no file descriptors on AIX
1300
1301    // we only need to attach to a process that is not our direct children.
1302
1303    //ccw 30 apr 2002 : SPLIT5
1304    pdstring buffer ="attach!";
1305    statusLine(buffer.c_str());
1306    
1307    if (proc_->parent != 0 || proc_->createdViaAttach) {
1308       return attach_helper(proc_);
1309    }
1310    else
1311       return true;
1312 }
1313
1314 pdstring process::tryToFindExecutable(const pdstring &progpath, int /*pid*/) {
1315    // returns empty string on failure
1316
1317     if (!progpath.length())
1318         cerr << "Warning: Attach on AIX requires program path to be specified" << endl;
1319     if (progpath.length() == 0)
1320         return "";
1321     if (exists_executable(progpath)) // util lib
1322         return progpath;
1323     
1324     return ""; // failure
1325 }
1326
1327 bool process::installSyscallTracing() {
1328     // turn on 'multiprocess debugging', which allows ptracing of both the
1329     // parent and child after a fork.  In particular, both parent & child will
1330     // TRAP after a fork.  Also, a process will TRAP after an exec (after the
1331     // new image has loaded but before it has started to execute at all).
1332     // Note that turning on multiprocess debugging enables two new values to be
1333     // returned by wait(): W_SEWTED and W_SFWTED, which indicate stops during
1334     // execution of exec and fork, respectively.
1335     // Should do this in loadSharedObjects
1336     // Note: this can also get called when we incrementally find a shared object.
1337     // So? :)
1338     ptrace(PT_MULTI, getPid(), 0, 1, 0);
1339
1340     // We mimic system call tracing via instrumentation
1341     
1342     // Pre-fork (is this strictly necessary?
1343     tracingRequests += new instMapping("libc.a/fork", "DYNINST_instForkEntry",
1344                                        FUNC_ENTRY);
1345     // Post-fork: handled for us by the system
1346
1347     // Pre-exec: get the exec'ed file name
1348     AstNode *arg1 = new AstNode(AstNode::Param, (void *)0);
1349     tracingRequests += new instMapping("libc.a/execve", "DYNINST_instExecEntry",
1350                                        FUNC_ENTRY|FUNC_ARG,
1351                                        arg1);
1352     // Post-exec: handled for us by the system
1353
1354     // Pre-exit: get the return code
1355     
1356     tracingRequests += new instMapping("libc.a/exit", "DYNINST_instExitEntry",
1357                                        FUNC_ENTRY|FUNC_ARG,
1358                                        arg1);
1359     
1360     // Post-exit: handled for us by the system
1361     removeAst(arg1);
1362
1363     return true;
1364 }
1365
1366
1367
1368 procSyscall_t decodeSyscall(process *, procSignalWhat_t what)
1369 {
1370    switch (what) {
1371      case SYS_fork:
1372         return procSysFork;
1373         break;
1374      case SYS_exec:
1375         return procSysExec;
1376         break;
1377      case SYS_load:
1378         return procSysLoad;
1379         break;
1380      case SYS_exit:
1381         return procSysExit;
1382         break;
1383      default:
1384         return procSysOther;
1385         break;
1386    }
1387    assert(0);
1388    return procSysOther;
1389 }
1390
1391 int decodeRTSignal(process *proc,
1392                    procSignalWhy_t &why,
1393                    procSignalWhat_t &what,
1394                    procSignalInfo_t &info)
1395 {
1396     // We've received a signal we believe was sent
1397     // from the runtime library. Check the RT lib's
1398     // status variable and return it.
1399     // These should be made constants
1400     pdstring status_str = pdstring("DYNINST_instSyscallState");
1401     pdstring arg_str = pdstring("DYNINST_instSyscallArg1");
1402
1403     int status;
1404     Address arg;
1405
1406     bool err = false;
1407     Address status_addr = proc->findInternalAddress(status_str, false, err);
1408     if (err) {
1409         // Couldn't find symbol
1410         return 0;
1411     }
1412     if (!proc->readDataSpace((void *)status_addr, sizeof(int), 
1413                              &status, true)) {
1414         return 0;
1415     }
1416
1417     if (status == 0) {
1418         return 0; // Nothing to see here
1419     }
1420     
1421     Address arg_addr = proc->findInternalAddress(arg_str, false, err);
1422     if (err) {
1423     }
1424     
1425     if (!proc->readDataSpace((void *)arg_addr, sizeof(Address),
1426                              &arg, true))
1427         assert(0);
1428     info = (procSignalInfo_t)arg;
1429
1430     // We need to clear out the DYNINST_instSyscallState variable
1431     // immediately.  I've run into a problem where we handle a fork (ie.  a
1432     // stop in the application initiated from our instrumenting fork exit)
1433     // and then we issue SIGSTOP in loopUntilStopped but we're still stopped
1434     // here after the fork.  We'll think this second stop at the fork exit is
1435     // for handling the fork, when really it was just an ordinary stop
1436     // initiated through loopUntilStopped.
1437     int init_status = 0;
1438     proc->writeDataSpace((void*)status_addr, sizeof(int), &init_status);
1439
1440     switch(status) {
1441   case 1:
1442       /* Entry to fork */
1443       why = procSyscallEntry;
1444       what = SYS_fork;
1445       break;
1446   case 2:
1447       /* Exit of fork, unused */
1448       break;
1449   case 3:
1450       /* Entry to exec */
1451       why = procSyscallEntry;
1452       what = SYS_exec;
1453       break;
1454   case 4:
1455       /* Exit of exec, unused */
1456       break;
1457   case 5:
1458       /* Entry of exit, used for the callback. We need to trap before
1459          the process has actually exited as the callback may want to
1460          read from the process */
1461       why = procSyscallEntry;
1462       what = SYS_exit;
1463       break;
1464   default:
1465       assert(0);
1466       break;
1467     }
1468     return 1;
1469
1470 }
1471
1472 // the pertinantLWP and wait_options are ignored on Solaris, AIX
1473
1474 bool signalHandler::checkForProcessEvents(pdvector<procevent *> *events,
1475                                           int wait_arg, int &timeout)
1476 {
1477     int options;
1478     if (-1 == timeout) options = 0; // blocking waitpid
1479     else options = WNOHANG;
1480     process *proc = NULL;
1481     int result = 0;
1482     int status;
1483
1484     result = waitpid( wait_arg, &status, options );
1485
1486     struct timespec slp, rem;
1487     if (-1 != timeout) {
1488        //  sleep for <timeout> and try again
1489       if (timeout > 1000) {
1490         slp.tv_sec = timeout / 1000;
1491         slp.tv_nsec = (timeout % 1000) /*ms*/ * 1000 /*us*/ * 1000 /*ns*/;
1492       }
1493       else {
1494         slp.tv_sec = 0;
1495         slp.tv_nsec = timeout /*ms*/ * 1000 /*us*/ * 1000 /*ns*/;
1496       }
1497       if (-1 == nanosleep(&slp, &rem)) {
1498         fprintf(stderr, "%s[%d]:  nanosleep: %d:%s\n", __FILE__, __LINE__,
1499                errno, strerror(errno));
1500       }
1501
1502       //  can check remaining time to see if we have _really_ timed out
1503       //  (but do we really care?)
1504
1505       result = waitpid( wait_arg, &status, options );
1506       timeout = 0; // we have timed out
1507     }
1508
1509     procSignalWhy_t  why  = procUndefined;
1510     procSignalWhat_t what = 0;
1511     procSignalInfo_t info = 0;
1512
1513     // Translate the signal into a why/what combo.
1514     // We can fake results here as well: translate a stop in fork
1515     // to a (SYSEXIT,fork) pair. Don't do that yet.
1516     if (result > 0) {
1517         proc = process::findProcess(result);
1518
1519         if (!proc) {
1520             // This happens if we fork -- we get a trap from both the
1521             // parent and the child, but the child came first (and so
1522             // we have no clue about it). This is handled specially in the
1523             // fork case below.
1524         }
1525
1526         if (proc) {
1527             // Processes' state is saved in preSignalStatus()
1528             proc->savePreSignalStatus();
1529             // Got a signal, process is stopped.
1530             proc->set_status(stopped);
1531             
1532         }
1533         
1534         if (WIFEXITED(status)) {
1535             // Process exited via signal
1536             why = procExitedNormally;
1537             what = WEXITSTATUS(status);
1538             }
1539         else if (WIFSIGNALED(status)) {
1540             why = procExitedViaSignal;
1541             what = WTERMSIG(status);
1542         }
1543         else if (WIFSTOPPED(status)) {
1544             // More interesting (and common) case
1545             // This is where return value faking would occur
1546             // as well. procSignalled is a generic return.
1547             // For example, we translate SIGILL to SIGTRAP
1548             // in a few cases    
1549             why = procSignalled;
1550             what = WSTOPSIG(status);
1551             // AIX returns status information in the guise
1552             // of a trap. In this case, fake the info to 
1553             // the form we want.
1554             if (what == SIGSTOP) {
1555                 // Not due to a ptrace-derived signal, see if it is
1556                 // from the RT lib
1557                 // Only overwrites why,what,info if the signal is from the RT
1558                 decodeRTSignal(proc, why, what, info);
1559             }
1560             else if (what == SIGTRAP) {
1561                 if(proc->childHasSignalled() && status==0x57f) {
1562                     // This admittedly is a hack.  Occasionally, we'll get the
1563                     // trap from the child indicating fork exit, but we'll
1564                     // never get the trap from the parent indicating fork exit.
1565                     // In this case though, we do appear to reliably get a trap
1566                     // from the parent with an unexpected status value (0x57f).
1567                     // We're using this trap as the fork event from the parent.
1568                     status = W_SFWTED;
1569                 }
1570                 
1571                 switch(status & 0x7f) {
1572               case W_SLWTED:
1573                   // Load
1574                   why = procSyscallExit;
1575                   what = SYS_load;
1576                   static bool in_trap_loop = false;
1577                   static int recurse_level = 0;
1578                   // Debug info
1579                   dyn_saved_regs regs;
1580                   proc->getRepresentativeLWP()->getRegisters(&regs);
1581                   if (proc->previousSignalAddr() == regs.gprs[3]) {
1582                       if (!in_trap_loop) {
1583                           bperr( "Spinning to handle multiple traps caused by null library loads...\n");
1584                           in_trap_loop = true;
1585                       }
1586                       
1587                       // Nothing to see here, move along... you get the idea
1588                       proc->continueProc();
1589                       
1590                       // Even if we perform no processing, we still get a big
1591                       // slowdown because we don't check for signals often enough.
1592                       // So we wait until we get a valid event.
1593                       
1594                       // We don't want to spin completely, since that makes the
1595                       // daemon appear to have hung from the outside. So eat the
1596                       // first, say, 50 signals... then return control to the
1597                       // main event loop for a second.
1598                       if (recurse_level < 50) { // Made up constant
1599                           recurse_level++;
1600                           // Allow the process a bit of time
1601                           usleep(500);
1602                           return checkForProcessEvents(events, wait_arg,timeout);
1603                       }
1604                       else {
1605                           recurse_level = 0;
1606                           return false;
1607                       }
1608                   }
1609                   else if (in_trap_loop) {
1610                       bperr("Finished spinning, returning to normal processing.\n");
1611                       in_trap_loop = false;
1612                   }
1613                   proc->setPreviousSignalAddr(regs.gprs[3]); 
1614                   break;
1615               case W_SFWTED:
1616                   // Fork
1617                   why = procSyscallExit;
1618                   what = SYS_fork;
1619                   
1620                   if (proc) {
1621                       // We're the parent, since the child doesn't have a
1622                       // process object
1623                       int childPid = proc->childHasSignalled();
1624                       if (childPid) {
1625                           info = childPid;
1626                           // successfully noticed a fork (both parent and
1627                           // child), reset state variables this allows
1628                           // successive forks to work
1629                           proc->setChildHasSignalled(0);
1630                           proc->setParentHasSignalled(0);
1631                       }
1632                       else {
1633                           // Haven't seen the child yet, so 
1634                           // discard this signal. We'll use the child
1635                           // trap to begin fork handling
1636                           proc->setParentHasSignalled(result);
1637                       }
1638                   }
1639                   else {
1640                       // Child-side. See if the parent has trapped yet.
1641                       // Uh... who is our parent?
1642                       struct procsinfo psinfo;
1643                       pid_t temp_child_pid = result;
1644                       if (getprocs(&psinfo, sizeof(psinfo), NULL, 0, &temp_child_pid, 1) 
1645                           == -1) {
1646                           assert(false);
1647                           return false;
1648                       }
1649                       
1650                       assert((pid_t)psinfo.pi_pid == result);
1651                       
1652                       int parentPid = psinfo.pi_ppid;
1653                       process *parent = process::findProcess(parentPid);
1654                       if (parent->parentHasSignalled()) {
1655                           // Parent trap was already hit, so do the work here
1656                           proc = parent;
1657                           info = result;
1658                           // successfully noticed a fork, reset state variables
1659                           proc->setChildHasSignalled(0);
1660                           proc->setParentHasSignalled(0);
1661                        }
1662                        else {
1663                           //Parent hasn't been seen yet, set variables and wait
1664                           parent->setChildHasSignalled(result);
1665                        }
1666                     }
1667                     break;
1668                  case W_SEWTED:
1669                     // Exec
1670                     why = procSyscallExit;
1671                     what = SYS_exec;
1672                     break;
1673                  default:                  
1674                      // Check to see if we've hit a "system call" trap
1675                      
1676                     break;
1677                }
1678             }
1679         }
1680         else {
1681             bperr( "Unknown status 0x%x for process %d\n",
1682                     status, result);
1683         }
1684         
1685     }
1686     else if (result < 0) {
1687         // Possible the process exited but we weren't aware of
1688         // it yet.
1689         proc = NULL;
1690         // If the errno is ECHILD we don't have any children. This
1691         // is acceptable -- so don't print tons of error messages
1692         if (errno != ECHILD) 
1693             perror("waitpid");
1694     }
1695
1696     if(proc == NULL) {
1697        return false;
1698     }
1699     
1700     procevent *new_event = new procevent;
1701     new_event->proc = proc;
1702     new_event->lwp  = proc->getRepresentativeLWP();
1703     new_event->why  = why;
1704     new_event->what = what;
1705     new_event->info = info;
1706     (*events).push_back(new_event);
1707
1708     return true;
1709 }
1710
1711