stackwalk/src/procstate.C

   1 /*
   2  * See the dyninst/COPYRIGHT file for copyright information.
   3  *
   4  * We provide the Paradyn Tools (below described as "Paradyn")
   5  * on an AS IS basis, and do not warrant its validity or performance.
   6  * We reserve the right to update, modify, or discontinue this
   7  * software at any time.  We shall have no obligation to supply such
   8  * updates or modifications or any other form of support to you.
   9  *
  10  * By your use of Paradyn, you understand and agree that we (or any
  11  * other person or entity with proprietary rights in Paradyn) are
  12  * under no obligation to provide either maintenance services,
  13  * update services, notices of latent defects, or correction of
  14  * defects for Paradyn.
  15  *
  16  * This library is free software; you can redistribute it and/or
  17  * modify it under the terms of the GNU Lesser General Public
  18  * License as published by the Free Software Foundation; either
  19  * version 2.1 of the License, or (at your option) any later version.
  20  *
  21  * This library is distributed in the hope that it will be useful,
  22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  24  * Lesser General Public License for more details.
  25  *
  26  * You should have received a copy of the GNU Lesser General Public
  27  * License along with this library; if not, write to the Free Software
  28  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  29  */
  30
  31 #include "stackwalk/h/swk_errors.h"
  32 #include "stackwalk/h/procstate.h"
  33 #include "stackwalk/src/libstate.h"
  34 #include "common/src/headers.h"
  35 #include <assert.h>
  36 #include <string>
  37 #include <vector>
  38
  39 using namespace Dyninst;
  40 using namespace Dyninst::Stackwalker;
  41 using namespace std;
  42
  43 class DefaultLibState : public LibraryState
  44 {
  45 public:
  46    DefaultLibState(ProcessState *parent) :
  47       LibraryState(parent)
  48    {
  49    }
  50
  51    virtual bool getLibraryAtAddr(Address, LibAddrPair &) {
  52       return false;
  53    }
  54
  55    virtual bool getLibraries(std::vector<LibAddrPair> &, bool) {
  56       return false;
  57    }
  58
  59    virtual void notifyOfUpdate() {
  60    }
  61
  62    virtual Address getLibTrapAddress() {
  63       return 0x0;
  64    }
  65
  66    ~DefaultLibState() {
  67    }
  68 };
  69
  70 std::map<Dyninst::PID, ProcessState *> ProcessState::proc_map;
  71
  72 ProcessState::ProcessState(Dyninst::PID pid_, std::string executable_path_) :
  73    pid(NULL_PID),
  74    library_tracker(NULL),
  75    walker(NULL),
  76    executable_path(executable_path_)
  77 {
  78    std::map<PID, ProcessState *>::iterator i = proc_map.find(pid_);
  79    if (i != proc_map.end())
  80    {
  81       sw_printf("[%s:%u] - Already attached to debuggee %d\n",
  82                 FILE__, __LINE__, pid_);
  83       setLastError(err_badparam, "Attach requested to already " \
  84                    "attached process");
  85       return;
  86    }
  87    setPid(pid_);
  88 }
  89
  90 void ProcessState::setPid(Dyninst::PID pid_)
  91 {
  92    pid = pid_;
  93    proc_map[pid] = this;
  94 }
  95
  96 Dyninst::PID ProcessState::getProcessId()
  97 {
  98    return pid;
  99 }
 100
 101 bool ProcessState::preStackwalk(Dyninst::THR_ID)
 102 {
 103    return true;
 104 }
 105
 106 bool ProcessState::postStackwalk(Dyninst::THR_ID)
 107 {
 108    return true;
 109 }
 110
 111 void ProcessState::setDefaultLibraryTracker()
 112 {
 113   if (library_tracker) return;
 114
 115   std::string execp("");
 116   ProcDebug *pd = dynamic_cast<ProcDebug *>(this);
 117   if (!library_tracker) {
 118      if (pd)
 119         execp = pd->getExecutablePath();
 120      library_tracker = new TrackLibState(this, execp);
 121   }
 122 }
 123
 124 Walker *ProcessState::getWalker() const
 125 {
 126    return walker;
 127 }
 128
 129 ProcessState::~ProcessState()
 130 {
 131    if (library_tracker)
 132       delete library_tracker;
 133    proc_map.erase(pid);
 134 }
 135
 136 ProcessState *ProcessState::getProcessStateByPid(Dyninst::PID pid) {
 137    map<PID, ProcessState *>::iterator i = proc_map.find(pid);
 138    if (i == proc_map.end())
 139       return NULL;
 140    return i->second;
 141 }
 142
 143 unsigned ProcSelf::getAddressWidth()
 144 {
 145    return sizeof(void *);
 146 }
 147
 148 bool ProcSelf::isFirstParty()
 149 {
 150   return true;
 151 }
 152
 153 ProcSelf::~ProcSelf()
 154 {
 155 }
 156
 157 LibraryState::LibraryState(ProcessState *parent) :
 158    procstate(parent)
 159 {
 160 }
 161
 162 LibraryState::~LibraryState()
 163 {
 164 }
 165
 166 LibraryState *ProcessState::getLibraryTracker()
 167 {
 168    return library_tracker;
 169 }
 170