common/src/addrtranslate-freebsd.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 #include "common/h/headers.h"
  33 #include "common/src/addrtranslate-sysv.h"
  34 #include "common/h/freebsdKludges.h"
  35
  36 #include <cstdio>
  37
  38 #include <sys/types.h>
  39 #include <sys/ptrace.h>
  40 #include <sys/wait.h>
  41 #include <errno.h>
  42 #include <unistd.h>
  43
  44 using namespace Dyninst;
  45
  46 class ProcessReaderPtrace : public ProcessReader {
  47     protected:
  48         int pid;
  49     public:
  50         ProcessReaderPtrace(int pid_);
  51         virtual bool start();
  52         virtual bool ReadMem(Address inTraced, void *inSelf, unsigned amount);
  53         virtual bool GetReg(MachRegister /*reg*/, MachRegisterVal &/*val*/) {
  54             assert(0);
  55             return false;
  56         }
  57         virtual bool done();
  58
  59         virtual ~ProcessReaderPtrace();
  60 };
  61
  62 bool ProcessReaderPtrace::start() {
  63     if( 0 != ptrace(PT_ATTACH, pid, (caddr_t)1, 0) ) {
  64         translate_printf("[%s:%u] - Failed to attach to process %u: %s\n",
  65                 __FILE__, __LINE__, pid, strerror(errno));
  66         return false;
  67     }
  68
  69     int status;
  70     while(true) {
  71         int result = (long) waitpid(pid, &status, 0);
  72         if (result == -1 && errno == EINTR) {
  73             continue;
  74         } else if (result == -1 || WIFEXITED(status) || WIFSIGNALED(status)) {
  75             translate_printf("[%s:%u] - Failed to stop process %u: %s\n",
  76                     __FILE__, __LINE__, pid, strerror(errno));
  77             done();
  78             return false;
  79         } else if (WIFSTOPPED(status) && (WSTOPSIG(status) == SIGSTOP
  80                 || WSTOPSIG(status) == SIGTRAP) ) {
  81             break;
  82         } else if (WIFSTOPPED(status) && WSTOPSIG(status) != SIGSTOP) {
  83             if( 0 != ptrace(PT_CONTINUE, pid, (caddr_t)1, WSTOPSIG(status)) ) {
  84                 translate_printf("[%s:%u] - Failed to continue process %u: %s\n"
  85                         __FILE__, __LINE__, pid, strerror(errno));
  86                 done();
  87                 return false;
  88             }
  89         } else {
  90             translate_printf("[%s:%u] - Unknown error encountered for process %u: %s\n",
  91                     __FILE__, __LINE__, pid, strerror(errno));
  92             done();
  93             return false;
  94         }
  95     }
  96
  97     return true;
  98 }
  99
 100 bool ProcessReaderPtrace::done()
 101 {
 102    return ( 0 != ptrace(PT_DETACH, pid, (caddr_t)1, 0) ) ? true : false;
 103 }
 104
 105 ProcessReaderPtrace::ProcessReaderPtrace(int pid_) :
 106    pid(pid_)
 107 {
 108 }
 109
 110 ProcessReaderPtrace::~ProcessReaderPtrace()
 111 {
 112 }
 113
 114 bool ProcessReaderPtrace::ReadMem(Address inTraced, void *inSelf, unsigned amount) {
 115     bool result = PtraceBulkRead(inTraced, amount, inSelf, pid);
 116     if( !result ) {
 117         translate_printf("[%s:%u] - Failed to read memory from process: %s\n",
 118                 __FILE__, __LINE__, strerror(errno));
 119     }
 120
 121     return result;
 122 }
 123
 124 /* Complete the implementation of the AddressTranslateSysV class */
 125
 126 ProcessReader *AddressTranslateSysV::createDefaultDebugger(int pid)
 127 {
 128   return new ProcessReaderPtrace(pid);
 129 }
 130
 131
 132 bool AddressTranslateSysV::setInterpreter() {
 133     if( interpreter ) return true;
 134
 135     string l_exec = getExecName();
 136     if( l_exec.empty() ) {
 137         return false;
 138     }
 139
 140     FCNode *exe = files.getNode(l_exec, symfactory);
 141     if( !exe ) {
 142         translate_printf("[%s:%u] - Failed to get FCNode for %s\n",
 143                 __FILE__, __LINE__, l_exec.c_str());
 144         return false;
 145     }
 146
 147     if( exe->getInterpreter().empty() ) {
 148         translate_printf("[%s:%u] - No interpreter found\n",
 149                 __FILE__, __LINE__);
 150         return true;
 151     }
 152
 153     interpreter = files.getNode(exe->getInterpreter(), symfactory);
 154     if( interpreter ) interpreter->markInterpreter();
 155     else{
 156         translate_printf("[%s:%u] - Failed to set interpreter for %s\n",
 157                 __FILE__, __LINE__, l_exec.c_str());
 158         return false;
 159     }
 160
 161     return true;
 162 }
 163
 164 bool AddressTranslateSysV::setAddressSize() {
 165     if (address_size) return true;
 166
 167     if( (address_size = sysctl_computeAddrWidth(pid)) == -1 ) {
 168         address_size = 0;
 169         return false;
 170     }
 171
 172     return true;
 173 }
 174
 175 bool AddressTranslateSysV::setInterpreterBase() {
 176     if( set_interp_base ) return true;
 177
 178     string l_exec = getExecName();
 179     if( l_exec.empty() ) {
 180         return false;
 181     }
 182
 183     FCNode *exe = files.getNode(l_exec, symfactory);
 184     if( !exe ) {
 185         translate_printf("[%s:%u] - Failed to get FCNode for %s\n",
 186                 __FILE__, __LINE__, l_exec.c_str());
 187         return false;
 188     }
 189
 190     unsigned maps_size;
 191     map_entries *maps = getVMMaps(pid, maps_size);
 192     if( !maps ) {
 193         translate_printf("[%s:%u] - Failed to get VM maps\n",
 194                 __FILE__, __LINE__);
 195         return false;
 196     }
 197
 198     string interp_name = exe->getInterpreter();
 199     for(unsigned i = 0; i < maps_size; ++i) {
 200         if( string(maps[i].path) == interp_name ) {
 201             interpreter_base = maps[i].start;
 202             set_interp_base = true;
 203             break;
 204         }
 205     }
 206     free(maps);
 207
 208     if( !set_interp_base ) {
 209         translate_printf("[%s:%u] - Failed to get locate interpreter in memory map\n",
 210                 __FILE__, __LINE__);
 211         return false;
 212     }
 213
 214     return true;
 215 }
 216
 217 const string& AddressTranslateSysV::getExecName() {
 218     if( exec_name.empty() ) {
 219         char *pathname = sysctl_getExecPathname(pid);
 220         if( NULL != pathname ) {
 221             exec_name = std::string(pathname);
 222
 223             free(pathname);
 224         }
 225     }
 226     return exec_name;
 227 }
 228
 229 LoadedLib *AddressTranslateSysV::getAOut()
 230 {
 231    // TODO: shouldn't this just return exec if it's set?
 232    LoadedLib *ll = new LoadedLib(getExecName(), 0);
 233    ll->setFactory(symfactory);
 234    return ll;
 235 }