Update copyright to LGPL on all files
[dyninst.git] / dyninstAPI / src / rpcMgr-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 #include "common/h/headers.h"
32 #include "dyninstAPI/src/dyn_lwp.h"
33 #include "dyninstAPI/src/process.h"
34 #include "dyninstAPI/src/rpcMgr.h"
35 #include "dyninstAPI/src/mailbox.h"
36 #include "dyninstAPI/src/callbacks.h"
37 #include "dyninstAPI/src/registerSpace.h"
38 #include "dyninstAPI/src/dyn_lwp.h"
39
40 rpcLWP::rpcLWP(rpcLWP *parL, rpcMgr *cM, dyn_lwp *cL) :
41     mgr_(cM),
42     lwp_(cL),
43     pendingRPC_(NULL),
44     runningRPC_(NULL)
45 {
46     for (unsigned i = 0; i < parL->postedRPCs_.size(); i++) {
47         inferiorRPCtoDo *newRPC = new inferiorRPCtoDo;
48         inferiorRPCtoDo *oldRPC = parL->postedRPCs_[i];
49
50         newRPC->action = oldRPC->action;
51         newRPC->noCost = oldRPC->noCost;
52         newRPC->callbackFunc = oldRPC->callbackFunc;
53         newRPC->userData = oldRPC->userData;
54         newRPC->lowmem = oldRPC->lowmem;
55         newRPC->id = oldRPC->id;
56         assert(!oldRPC->thr);
57         assert(oldRPC->lwp);
58         newRPC->lwp = cL;
59         postedRPCs_.push_back(newRPC);
60     }
61     if (parL->pendingRPC_) {
62         inferiorRPCinProgress *newProg = new inferiorRPCinProgress;
63         inferiorRPCinProgress *oldProg = parL->pendingRPC_;
64         
65         inferiorRPCtoDo *newRPC = new inferiorRPCtoDo;
66         inferiorRPCtoDo *oldRPC = oldProg->rpc;
67
68         newRPC->action = oldRPC->action;
69         newRPC->noCost = oldRPC->noCost;
70         newRPC->callbackFunc = oldRPC->callbackFunc;
71         newRPC->userData = oldRPC->userData;
72         newRPC->lowmem = oldRPC->lowmem;
73         newRPC->id = oldRPC->id;
74         assert(!oldRPC->thr);
75         newRPC->lwp = cL;
76         assert(oldRPC->lwp);
77         
78         newProg->rpc = newRPC;
79         if (oldProg->savedRegs) {
80             newProg->savedRegs = new dyn_saved_regs;
81             memcpy(newProg->savedRegs, oldProg->savedRegs, sizeof(dyn_saved_regs));
82         }
83         else newProg->savedRegs = NULL;
84         newProg->origPC = oldProg->origPC;
85         newProg->runProcWhenDone = oldProg->runProcWhenDone;
86         newProg->rpcBaseAddr = oldProg->rpcBaseAddr;
87         newProg->rpcStartAddr = oldProg->rpcStartAddr;
88         newProg->rpcResultAddr = oldProg->rpcResultAddr;
89         newProg->rpcContPostResultAddr = oldProg->rpcContPostResultAddr;
90         newProg->rpcCompletionAddr = oldProg->rpcCompletionAddr;
91         newProg->resultRegister = oldProg->resultRegister;
92         newProg->resultValue = oldProg->resultValue;
93         
94         newProg->rpcthr = NULL;
95         newProg->rpclwp = this;
96         newProg->isProcessRPC = oldProg->isProcessRPC;
97         newProg->state = oldProg->state;
98         
99         pendingRPC_ =  newProg;
100     }
101         
102     if (parL->runningRPC_) {
103         inferiorRPCinProgress *newProg = new inferiorRPCinProgress;
104         inferiorRPCinProgress *oldProg = parL->runningRPC_;
105         
106         inferiorRPCtoDo *newRPC = new inferiorRPCtoDo;
107         inferiorRPCtoDo *oldRPC = oldProg->rpc;
108
109         newRPC->action = oldRPC->action;
110         newRPC->noCost = oldRPC->noCost;
111         newRPC->callbackFunc = oldRPC->callbackFunc;
112         newRPC->userData = oldRPC->userData;
113         newRPC->lowmem = oldRPC->lowmem;
114         newRPC->id = oldRPC->id;
115         assert(!oldRPC->thr);
116         newRPC->lwp = cL;
117         assert(oldRPC->lwp);
118         
119         newProg->rpc = newRPC;
120         if (oldProg->savedRegs) {
121             newProg->savedRegs = new dyn_saved_regs;
122             memcpy(newProg->savedRegs, oldProg->savedRegs, sizeof(dyn_saved_regs));
123         }
124         else newProg->savedRegs = NULL;
125         newProg->origPC = oldProg->origPC;
126         newProg->runProcWhenDone = oldProg->runProcWhenDone;
127         newProg->rpcBaseAddr = oldProg->rpcBaseAddr;
128         newProg->rpcStartAddr = oldProg->rpcStartAddr;
129         newProg->rpcResultAddr = oldProg->rpcResultAddr;
130         newProg->rpcContPostResultAddr = oldProg->rpcContPostResultAddr;
131         newProg->rpcCompletionAddr = oldProg->rpcCompletionAddr;
132         newProg->resultRegister = oldProg->resultRegister;
133         newProg->resultValue = oldProg->resultValue;
134         
135         newProg->rpcthr = NULL;
136         newProg->rpclwp = this;
137         newProg->isProcessRPC = oldProg->isProcessRPC;
138         newProg->state = oldProg->state;
139         
140         runningRPC_ =  newProg;
141     }
142 }
143     
144
145 int rpcLWP::postIRPC(inferiorRPCtoDo *todo) {
146     postedRPCs_.push_back(todo);
147     return todo->id;
148 }
149
150 bool rpcLWP::isProcessingIRPC() const {
151     return isRunningIRPC() || isWaitingForBreakpoint();
152 }
153
154 bool rpcLWP::isRunningIRPC() const {
155     return runningRPC_ != NULL;
156 }
157
158 bool rpcLWP::isWaitingForBreakpoint() const {
159     return pendingRPC_ != NULL;
160 }
161
162 // We _do not_ check process-wide RPCs here
163 bool rpcLWP::isReadyForIRPC() const {
164     if (isProcessingIRPC()) {
165        fprintf(stderr, "[%s:%u] - Already processing rpc\n", __FILE__, __LINE__);
166         return false;    }
167     if (postedRPCs_.size() > 0) {
168         return true;
169     }
170     
171     return false;
172 }
173
174 // Launch an inferior RPC
175 // Two cases: 
176 // 1) We have a pending RPC (in pendingRPC_) that we already prepped
177 //    and we want to run it (and a system call breakpoint was set)
178 // 2) We don't have a pending IRPC but there is one on the queue.
179 irpcLaunchState_t rpcLWP::launchLWPIRPC(bool runProcWhenDone) {
180     if (runningRPC_ || pendingRPC_) return irpcError;
181     
182     if (postedRPCs_.size() == 0)
183         // LWPs don't run proc-wide
184         return irpcNoIRPC;
185
186     // We can run the RPC if we're not currently in a system call.
187     // This is defined as "any time we can't modify the state of the
188     // process". In this case we try and set a breakpoint when we leave
189     // the system call. If we can't set the breakpoint we poll.
190
191     if (mgr_->proc()->IndependentLwpControl())
192         lwp_->pauseLWP(true);
193     
194 #if defined(cap_syscall_trap)
195     // Check if we're in a system call
196     if (lwp_->executingSystemCall()) {
197         // We can't do any work. If there is a pending RPC try
198         // to set a breakpoint at the exit of the call
199         if (lwp_->setSyscallExitTrap(launchLWPIRPCCallbackDispatch,
200                                      (void *)this)) {
201             // If there is an RPC queued we set it up as pending
202             // and record it
203             if (!pendingRPC_) {
204                 pendingRPC_ = new inferiorRPCinProgress;
205                 pendingRPC_->rpc = postedRPCs_[0];
206                 pendingRPC_->runProcWhenDone = runProcWhenDone;
207                 // Delete that iRPC (clunky)
208                 pdvector<inferiorRPCtoDo *> newRPCs;
209                 for (unsigned k = 1; k < postedRPCs_.size(); k++)
210                     newRPCs.push_back(postedRPCs_[k]);
211                 postedRPCs_ = newRPCs;
212                 mgr_->addPendingRPC(pendingRPC_);
213             }
214             if (mgr_->proc()->IndependentLwpControl())
215                 lwp_->continueLWP(true, false);
216             return irpcBreakpointSet;
217         }
218         else {
219             // Weren't able to set the breakpoint, so all we can
220             // do is try later
221             // Don't set pending if we're polling.
222             assert(!pendingRPC_);
223             if (mgr_->proc()->IndependentLwpControl())
224                 lwp_->continueLWP(true, false);
225             return irpcAgain;
226         }
227     }
228 #endif // cap_syscall_trap
229     
230     // Get the RPC and slap it in the postedRPC_ pointer
231     if (!pendingRPC_) {
232         pendingRPC_ = new inferiorRPCinProgress;
233         if (postedRPCs_.size() > 0) {       
234             pendingRPC_->rpc = postedRPCs_[0];
235             // Delete that iRPC (clunky)
236             pdvector<inferiorRPCtoDo *> newRPCs;
237             for (unsigned k = 1; k < postedRPCs_.size(); k++)
238                 newRPCs.push_back(postedRPCs_[k]);
239             postedRPCs_ = newRPCs;
240         }
241         pendingRPC_->runProcWhenDone = runProcWhenDone;
242         mgr_->addPendingRPC(pendingRPC_);
243     }
244     
245     return runPendingIRPC();
246 }
247
248 irpcLaunchState_t rpcLWP::runPendingIRPC() {
249     // CHECK FOR SYSTEM CALL STATUS
250     assert(pendingRPC_);
251
252     // We passed the system call check, so the lwp is in a state
253     // where it is possible to run iRPCs.
254     struct dyn_saved_regs *theSavedRegs = NULL;
255     // Some platforms save daemon-side, some save process-side (on the stack)
256     // Should unify this.
257     theSavedRegs = new dyn_saved_regs;
258
259     Frame frame = lwp_->getActiveFrame();
260     inferiorrpc_printf("%s[%d]: original PC at start of iRPC is 0x%lx\n", FILE__, __LINE__, frame.getPC());
261     
262     bool saveFP = pendingRPC_->rpc->saveFPState;
263     bool status = lwp_->getRegisters(theSavedRegs, saveFP);
264     if(status != true) {
265         // Can happen if we're in a syscall, which is caught above
266         return irpcError;
267     }
268     // RPC is actually going to be running
269     runningRPC_ = pendingRPC_;
270     pendingRPC_ = NULL;
271     
272     // Build the in progress struct
273     runningRPC_->savedRegs = theSavedRegs;
274     runningRPC_->rpcthr = NULL;
275     runningRPC_->rpclwp = this;
276
277     mgr_->addRunningRPC(runningRPC_);
278
279     runningRPC_->rpcBaseAddr =
280     mgr_->createRPCImage(runningRPC_->rpc->action, // AST tree
281                          runningRPC_->rpc->noCost,
282                          (runningRPC_->rpc->callbackFunc != NULL), // Callback?
283                          runningRPC_->rpcStartAddr,
284                          runningRPC_->rpcCompletionAddr, // Fills in 
285                          runningRPC_->rpcResultAddr,
286                          runningRPC_->rpcContPostResultAddr,
287                          runningRPC_->resultRegister,
288                          runningRPC_->rpc->lowmem, 
289                          NULL, lwp_); // Where to allocate
290     if (!runningRPC_->rpcBaseAddr) {
291         cerr << "launchRPC failed, couldn't create image" << endl;
292         return irpcError;
293     }
294     
295     /* Why we don't just pass runningRPC_ into createRPCImage()... */
296         mgr_->proc()->addOrigRange( runningRPC_ );
297
298 #if !defined(i386_unknown_nt4_0) \
299  && !defined(mips_unknown_ce2_11)
300     // Actually, only need this if a restoreRegisters won't reset
301     // the PC back to the original value
302     Frame curFrame = lwp_->getActiveFrame();
303     runningRPC_->origPC = curFrame.getPC();
304 #endif    
305
306     // Launch this sucker. Change the PC, and the caller will set running
307 #if ! defined( ia64_unknown_linux2_4 )    
308     if (!lwp_->changePC(runningRPC_->rpcStartAddr, NULL)) {
309 #else    
310     /* Syscalls can actually rewind the PC by 0x10, so we need
311        a bundle _before_ the new PC to check for this. */
312    if (!lwp_->changePC(runningRPC_->rpcStartAddr + 0x10, NULL)) {
313 #endif    
314         cerr << "launchRPC failed: couldn't set PC" << endl;
315         return irpcError;
316     }
317     
318 #if defined(i386_unknown_linux2_0) \
319  || defined(x86_64_unknown_linux2_4) /* Blind duplication - Ray */
320       // handle system call interruption:
321       // if we interupted a system call, this clears the state that
322       // would cause the OS to restart the call when we run the rpc.
323       // if we did not, this is a no-op.
324       // after the rpc, an interrupted system call will
325       // be restarted when we restore the original
326       // registers (restore undoes clearOPC)
327       // note that executingSystemCall is always false on this platform.
328       if (!lwp_->clearOPC())
329       {
330          cerr << "launchRPC failed because clearOPC() failed" << endl;
331          return irpcError;
332       }
333 #endif
334
335       if (mgr_->proc()->IndependentLwpControl()) {
336           signal_printf("%s[%d]: Continuing lwp %d\n", FILE__, __LINE__, lwp_->get_lwp_id());
337           lwp_->continueLWP(NoSignal, false);
338       }
339
340       return irpcStarted;
341 }
342
343 bool rpcLWP::deleteLWPIRPC(unsigned id) {
344     // Can remove a queued or pending lwp IRPC
345     bool removed = false;
346     
347     if (pendingRPC_ && pendingRPC_->rpc->id == id) {
348        // we don't want to do as we normally do when a exit trap occurs,
349        // that is to run the rpc, which gets triggered by this callback
350 #if defined(cap_syscall_trap)
351        get_lwp()->clearSyscallExitTrap();
352 #endif
353        delete pendingRPC_->rpc;
354        delete pendingRPC_;
355        pendingRPC_ = NULL;
356        
357        // Should probably also remove a system call trap
358        // if one exists
359        
360        return true;
361     }
362     
363     pdvector<inferiorRPCtoDo *> newPostedRPCs;
364     for (unsigned i = 0; i < postedRPCs_.size(); i++) {
365         if (postedRPCs_[i]->id == id) {
366             removed = true;
367         }
368         else {
369             newPostedRPCs.push_back(postedRPCs_[i]);
370         }
371     }
372     postedRPCs_ = newPostedRPCs;
373     return removed;
374 }
375
376 bool rpcLWP::cancelLWPIRPC(unsigned id) {
377   // It better be running...
378   assert (runningRPC_->rpc->id == id);
379
380   // We handle it as a completed, no-callback IRPC
381   runningRPC_->rpc->callbackFunc = NULL; /* Void the callback */
382
383   // I don't want to deal with "it finished" races...
384   assert(mgr_->proc()->isStopped());
385
386   return handleCompletedIRPC();
387 }
388
389
390 bool rpcLWP::handleCompletedIRPC() 
391 {
392   inferiorrpc_cerr << "Completed lwp RPC " << runningRPC_->rpc->id << " on lwp " << lwp_->get_lwp_id() << endl;
393
394     // step 1) restore registers:
395   if (runningRPC_->savedRegs) {
396       bool savedFP = runningRPC_->rpc->saveFPState;
397       if (!lwp_->restoreRegisters(*runningRPC_->savedRegs, savedFP)) {
398           cerr << "handleCompletedIRPC failed because restoreRegisters failed" << endl;
399           assert(false);
400       }
401       delete runningRPC_->savedRegs;
402       // The above implicitly must restore the PC.
403   }
404   else {
405       inferiorrpc_printf("%s[%d]: odd case with no saved registers, changing PC to 0x%lx\n",
406                          FILE__, __LINE__, runningRPC_->origPC);
407       if (!lwp_->changePC(runningRPC_->origPC, NULL)) 
408           assert(0 && "Failed to reset PC");
409   }
410   
411   // step 2) delete temp tramp
412   process *proc = lwp_->proc();
413   proc->removeOrigRange(runningRPC_);
414   proc->inferiorFree(runningRPC_->rpcBaseAddr);
415   
416     // save enough information to call the callback function, if needed
417     inferiorRPCcallbackFunc cb = runningRPC_->rpc->callbackFunc;
418     void* userData = runningRPC_->rpc->userData;
419     void* resultValue = runningRPC_->resultValue;
420     unsigned id = runningRPC_->rpc->id;
421
422     // Save whether we were running or not
423     bool runProcess = runningRPC_->runProcWhenDone;
424     
425     // And blow away the data structures
426     mgr_->removeRunningRPC(runningRPC_);
427     delete runningRPC_->rpc;
428     delete runningRPC_;
429     runningRPC_ = NULL;
430
431
432     int retstate = 0;
433     // step 3) invoke user callback, if any
434     // call the callback function if needed
435     if( cb != NULL ) {
436         retstate = cb(proc, id, userData, resultValue);
437         inferiorrpc_printf("%s[%d][%s]:  registered/exec'd callback %p\n", 
438                            FILE__, __LINE__, getThreadStr(getExecThreadID()), 
439                            (void *) (*cb));
440     }
441
442     // Before we continue the process: if there is another RPC,
443     // start it immediately (instead of waiting for an event loop
444     // to do the job)
445     if (isReadyForIRPC()) {
446         irpcLaunchState_t launchState =
447         launchLWPIRPC(runProcess);
448         if (launchState == irpcStarted) {
449             // Run the process
450             return true;
451         }
452     }
453     if (retstate == RPC_RUN_WHEN_DONE)  {
454         return true;
455     }
456     return runProcess;
457 }
458
459 // Get the return value (preperatory for a callback)
460 bool rpcLWP::getReturnValueIRPC() 
461 {
462     if (!runningRPC_ || !runningRPC_->rpc->callbackFunc)
463         return false;
464     Address returnValue = 0;
465     
466     if (runningRPC_->resultRegister != Null_Register) {
467         // We have a result that we care about
468         returnValue = lwp_->readRegister(runningRPC_->resultRegister);
469     }
470
471     runningRPC_->resultValue = (void *)returnValue;
472     // we continue the process...but not quite at the PC where we left off,
473     // since that will just re-do the trap!  Instead, we need to continue at
474     // the location of the next instruction.
475     if (!lwp_->changePC(runningRPC_->rpcContPostResultAddr, NULL))
476         assert(false);
477     return true;
478 }
479
480 bool rpcLWP::launchLWPIRPCCallbackDispatch(dyn_lwp * /*lwp*/,
481                                            void *data)
482 {
483     rpcLWP *lwp = (rpcLWP *)data;
484     
485     // the runProcess code here is ignored if a pending RPC
486     // is already set (which must be true for this callback to
487     // happen)
488     irpcLaunchState_t launchState = lwp->runPendingIRPC();
489     if (launchState == irpcStarted)
490       return true; // continue
491     return false;
492 }