Update copyright to LGPL on all files
[dyninst.git] / dyninstAPI / src / dyn_lwp.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 /*
33  * dyn_lwp.C -- cross-platform segments of the LWP handler class
34  * $Id: dyn_lwp.C,v 1.68 2008/04/15 16:43:13 roundy Exp $
35  */
36
37 #include "common/h/headers.h"
38 #include "dyn_lwp.h"
39 #include "process.h"
40 #include "debuggerinterface.h"
41 #include <assert.h>
42 #include "signalgenerator.h"
43
44 dyn_lwp::dyn_lwp() :
45   changedPCvalue(0),
46   status_(neonatal),
47   proc_(NULL),
48   lwp_id_(0),
49   fd_(0),
50   ctl_fd_(INVALID_HANDLE_VALUE),
51   status_fd_(INVALID_HANDLE_VALUE),
52   as_fd_(INVALID_HANDLE_VALUE),
53   auxv_fd_(INVALID_HANDLE_VALUE),
54   map_fd_(INVALID_HANDLE_VALUE),
55   ps_fd_(INVALID_HANDLE_VALUE),
56   procHandle_(INVALID_HANDLE_VALUE),
57   singleStepping(false),
58   stoppedInSyscall_(false),
59   postsyscallpc_(0),
60   waiting_for_stop(false),
61   threadInfoBlockAddr_(0),
62   trappedSyscall_(NULL), trappedSyscallCallback_(NULL),
63   trappedSyscallData_(NULL),
64   isRunningIRPC(false), isDoingAttach_(false), is_attached_(false),
65   is_as_lwp_(false),
66   is_dead_(false),
67   is_debugger_lwp(false)
68 {
69 };
70
71 dyn_lwp::dyn_lwp(unsigned lwp, process *proc) :
72   changedPCvalue(0),
73   status_(neonatal),
74   proc_(proc),
75   lwp_id_(lwp),
76   fd_(INVALID_HANDLE_VALUE),
77   ctl_fd_(INVALID_HANDLE_VALUE),
78   status_fd_(INVALID_HANDLE_VALUE),
79   as_fd_(INVALID_HANDLE_VALUE),
80   auxv_fd_(INVALID_HANDLE_VALUE),
81   map_fd_(INVALID_HANDLE_VALUE),
82   ps_fd_(INVALID_HANDLE_VALUE),
83   procHandle_(INVALID_HANDLE_VALUE),
84   singleStepping(false),
85   stoppedInSyscall_(false),
86   postsyscallpc_(0),
87   waiting_for_stop(false),
88   threadInfoBlockAddr_(0),
89   trappedSyscall_(NULL), trappedSyscallCallback_(NULL),
90   trappedSyscallData_(NULL),
91   isRunningIRPC(false), isDoingAttach_(false), is_attached_(false),
92   is_as_lwp_(false),
93   is_dead_(false),
94   is_debugger_lwp(false)
95 {
96 }
97
98 dyn_lwp::dyn_lwp(const dyn_lwp &l) :
99   changedPCvalue(0),
100   status_(neonatal),
101   proc_(l.proc_),
102   lwp_id_(l.lwp_id_),
103   fd_(INVALID_HANDLE_VALUE),
104   ctl_fd_(INVALID_HANDLE_VALUE),
105   status_fd_(INVALID_HANDLE_VALUE),
106   as_fd_(INVALID_HANDLE_VALUE),
107   auxv_fd_(INVALID_HANDLE_VALUE),
108   map_fd_(INVALID_HANDLE_VALUE),
109   ps_fd_(INVALID_HANDLE_VALUE),
110   procHandle_(INVALID_HANDLE_VALUE),
111   singleStepping(false),
112   stoppedInSyscall_(false),
113   postsyscallpc_(0),
114   waiting_for_stop(false),
115   threadInfoBlockAddr_(0),
116   trappedSyscall_(NULL), trappedSyscallCallback_(NULL),
117   trappedSyscallData_(NULL),
118   isRunningIRPC(false), isDoingAttach_(false), is_attached_(false),
119   is_as_lwp_(false),
120   is_dead_(false),
121   is_debugger_lwp(false)
122 {
123 }
124
125 dyn_lwp::~dyn_lwp()
126 {
127   if (status_ != exited && is_attached())
128     detach();
129 }
130
131 // TODO is this safe here ?
132 bool dyn_lwp::continueLWP(int signalToContinueWith, bool clear_stackwalk) 
133 {
134    if (clear_stackwalk) {
135       clearStackwalk();
136    }
137     if (!proc()->IndependentLwpControl() &&
138         (this != proc()->getRepresentativeLWP())) {
139         // This'll hit stop_, which calls pauseLWP on the representative LWP.
140         // Hence the comparison.
141         return proc()->continueProc(); 
142     }
143
144     assert(proc()->IndependentLwpControl() ||
145            (this == proc()->getRepresentativeLWP()));
146
147    if(status_ == running || isDoingAttach_) {
148       return true;
149    }
150 /*
151    if (status_ == exited) {
152        return true;
153    }
154 */
155    if (proc()->sh->waitingForStop())
156    {
157      return false;
158    }
159
160
161    bool ret = continueLWP_(signalToContinueWith);
162    if(ret == false) {
163       perror(NULL);
164       return false;
165    }
166
167 #if defined (os_windows)
168    if (status_ != exited)
169         proc()->set_lwp_status(this, running);
170    if (getExecThreadID() != proc()->sh->getThreadID()) {
171      signal_printf("%s[%d][%s]:  signalling active process\n", 
172                    FILE__, __LINE__, getThreadStr(getExecThreadID()));
173      proc()->sh->signalActiveProcess();
174    }
175    // no SIGSTOP on Windows, and also no such thing as continuing with signal
176 #else
177    if (signalToContinueWith != SIGSTOP)  {
178       proc()->set_lwp_status(this, running);
179       if (getExecThreadID() != proc()->sh->getThreadID()) {
180           signal_printf("%s[%d][%s]:  signalling active process from continueLWP\n", 
181                         FILE__, __LINE__, getThreadStr(getExecThreadID()));
182           proc()->sh->signalActiveProcess();
183       }
184    }
185 #endif
186    
187    // When we fork we may cross the streams (a sighandler from the parent controlling
188    // the child). Argh.
189    proc()->sh->markProcessContinue();
190
191    return true;
192 }
193
194
195 std::string dyn_lwp::getStatusAsString() const 
196 {
197    // useful for debugging
198    if (status_ == neonatal)
199       return "neonatal";
200    if (status_ == stopped)
201       return "stopped";
202    if (status_ == running)
203       return "running";
204    if (status_ == exited)
205       return "exited";
206    if (status_ == detached)
207        return "detached";
208    assert(false);
209    return "???";
210 }
211
212 bool dyn_lwp::pauseLWP(bool shouldWaitUntilStopped) {
213     if (!proc()->IndependentLwpControl() &&
214         (this != proc()->getRepresentativeLWP())) {
215         // This'll hit stop_, which calls pauseLWP on the representative LWP.
216         // Hence the comparison.
217         return proc()->pause(); 
218     }
219
220     assert(proc()->IndependentLwpControl() ||
221            (this == proc()->getRepresentativeLWP()));
222
223     
224     if (isDoingAttach_) {
225        // We'll get to it later...
226        return true;
227     }
228
229    // Not checking lwp status_ for neonatal because it breaks attach with the
230    // dyninst tests.  My guess is that somewhere we set the process status to
231    // running.  If we can find this, then we can set the lwp status to
232    // running also.
233
234     if(status_ == stopped || status_ == exited) {
235         return true;
236     }
237     
238     bool res = stop_();
239     if(res == false)
240         return false;
241     
242     if(shouldWaitUntilStopped) {
243         res = waitUntilStopped();
244     }
245     if(status_ == exited) {
246       return true;
247     }
248     
249     proc()->set_lwp_status(this, stopped);
250     return res;
251 }
252
253
254 // Not sure this is a good idea... when would we be walking the stack
255 // (conceptually) of an LWP rather than the thread running on it?  For now:
256 // non-MT will walk getRepresentativeLWP() since it doesn't understand
257 // multithreaded programs
258
259 void dyn_lwp::markDoneRunningIRPC() {
260    isRunningIRPC = false;
261 }
262
263 // stackWalk: return parameter.
264 bool dyn_lwp::markRunningIRPC() {
265    // Cache the current stack frame
266
267    Frame active = getActiveFrame();
268    isRunningIRPC = true;
269    return proc_->walkStackFromFrame(active, cached_stackwalk.getStackwalk());
270 }
271
272 bool dyn_lwp::walkStack(pdvector<Frame> &stackWalk, bool /* ignoreRPC = false */)
273 {
274    stackWalk.clear();
275    if (cached_stackwalk.isValid()) {
276       stackWalk = cached_stackwalk.getStackwalk();
277       return true;
278    }
279     
280    // We cheat (a bit): this method is here for transparency, 
281    // but the process class does the work in the walkStackFromFrame
282    // method. We get the active frame and hand off.
283    Frame active = getActiveFrame();
284    bool result = proc_->walkStackFromFrame(active, stackWalk);
285    if (result)
286       cached_stackwalk.setStackwalk(stackWalk);
287    return result;
288 }
289
290 bool dyn_lwp::attach() {
291    assert(!is_attached());
292    bool res;
293    if(this == proc()->getRepresentativeLWP()) {
294       res = representativeLWP_attach_();
295    }else {
296       res = realLWP_attach_();
297    }
298
299    if(res == true)
300       is_attached_ = true;
301
302    return res;
303 }
304
305 void dyn_lwp::detach() {
306    if(! is_attached())
307       return;
308
309    if(this == proc()->getRepresentativeLWP())
310       representativeLWP_detach_();
311    else
312       realLWP_detach_();
313
314    is_attached_ = false;
315 }
316
317 int dyn_lwp::getPid() const {
318    return proc_->getPid();
319 }
320
321 bool dyn_lwp::getRegisters(struct dyn_saved_regs *regs, bool includeFP) {
322         /* Don't cache registers.  It's broken on most platforms. */
323     return getRegisters_(regs, includeFP);
324         }
325
326 bool dyn_lwp::restoreRegisters(const struct dyn_saved_regs &regs, bool includeFP) {
327         /* Don't cache registers.  It's broken on most platforms. */
328     return restoreRegisters_(regs, includeFP);
329         }
330
331 // Find out some info about the system call we're waiting on,
332 // and ask the process class to set a breakpoint there. 
333
334 #if defined(cap_syscall_trap)
335 bool dyn_lwp::setSyscallExitTrap(syscallTrapCallbackLWP_t callback,
336                                  void *data)
337 {
338     assert(executingSystemCall());
339     if (trappedSyscall_) {
340         // Can't set trap twice
341         bperr( "Error: syscall already trapped on LWP %d\n",
342                 get_lwp_id());
343         return false;
344     }
345
346     Address syscallInfo = getCurrentSyscall();
347
348     if(syscallInfo == 0) return false;
349     signal_printf("%s[%d]: LWP %d placing syscall trap for %d (0x%lx)...\n",
350                   FILE__, __LINE__, get_lwp_id(),
351                   syscallInfo, syscallInfo);
352
353     trappedSyscall_ = proc()->trapSyscallExitInternal(syscallInfo);
354
355     assert(trappedSyscallCallback_ == NULL);
356     assert(trappedSyscallData_ == NULL);
357     trappedSyscallCallback_ = callback;
358     trappedSyscallData_ = data;
359
360     return (trappedSyscall_ != NULL);
361 }
362
363
364 // Clear the trap set
365
366 bool dyn_lwp::clearSyscallExitTrap()
367 {
368     assert(trappedSyscall_);
369     
370     if (!proc()->clearSyscallTrapInternal(trappedSyscall_))
371         return false;
372
373     trappedSyscall_ = NULL;
374     trappedSyscallCallback_ = NULL;
375     trappedSyscallData_ = NULL;
376     return true;
377 }
378
379 bool dyn_lwp::handleSyscallTrap(EventRecord &ev, bool &continueHint) 
380 {
381     // See if this is the right one...
382     if (ev.type != evtSyscallExit) return false;
383     if (!trappedSyscall_) return false;
384     if (ev.what != procSysOther) return false;
385
386     // Our event handling is a little skewed. We have a two-level
387     // structure: known syscalls (mapped to a local enumerated type)
388     // and unknown (with the syscall # in the info field).
389     // Let's assume for now that we only trap unknown syscalls...
390
391 #if !defined(os_windows)
392     if (ev.info != trappedSyscall_->syscall_id) return false;
393 #endif
394
395     // Step past the trap (if necessary)
396     stepPastSyscallTrap();
397
398     // Make a copy of the callback... we clear before we call,
399     // but clear is called from other locations as well.
400
401     syscallTrapCallbackLWP_t callback = trappedSyscallCallback_;
402     void *data = trappedSyscallData_;
403     
404     // And clear the callback
405     clearSyscallExitTrap();
406
407     // Make the callback
408     if (callback)
409       continueHint = (*callback)(this, data);
410
411     return true;
412 }
413
414 bool dyn_lwp::isWaitingForSyscall() const {
415     if (trappedSyscall_) return true;
416     else return false;
417 }
418 #endif // cap_syscall_trap
419
420 #if !defined(os_linux) && !defined(os_windows)
421 Address dyn_lwp::step_next_insn() {
422    fprintf(stderr, "Single stepping not implemented on this platform\n");
423    return 0x0;
424 }
425 #endif
426
427 void dyn_lwp::internal_lwp_set_status___(processState st) {
428         status_ = st;
429 }
430
431 bool dyn_lwp::is_asLWP() {
432     return is_as_lwp_;
433 }
434
435 void dyn_lwp::clearStackwalk() {
436    cached_stackwalk.clear();
437 }
438