process.cpp

Go to the documentation of this file.

#include "../include/process.hpp"
#include "../include/util.hpp"

namespace csdbg {

process& process::cache_add(mem_addr_t addr, const i8 *nm)
{
  util::lock();
  symbol *sym = NULL;
  try {
    sym = new symbol(addr, nm);
    m_symcache->add(sym);
  }

  catch (std::exception &x) {
    delete sym;
    util::dbg_error("in process::%s(): %s", __FUNCTION__, x.what());
  }

  util::unlock();
  return *this;
}


const symbol* process::cache_lookup(mem_addr_t addr) const
{
  util::lock();

  /*
   * Search the cache starting from the last entry (the latest added) to exploit
   * locality of reference
   */
  for (i32 i = m_symcache->size() - 1; likely(i >= 0); i--) {
    symbol *sym = m_symcache->at(i);
    if ( unlikely(sym->addr() == addr) ) {
      util::unlock();
      return sym;
    }
  }

  util::unlock();
  return NULL;
}


process::process()
try:
m_pid(getpid()),
m_threads(NULL),
m_modules(NULL),
m_symcache(NULL)
{
  m_threads = new chain<thread>;
  m_modules = new chain<symtab>;
  m_symcache = new chain<symbol>;
}

catch (...) {
  delete m_threads;
  delete m_modules;
  m_threads = NULL;
  m_modules = NULL;
}


process::process(const process &src)
try:
m_pid(src.m_pid),
m_threads(NULL),
m_modules(NULL),
m_symcache(NULL)
{
  util::lock();
  m_threads = src.m_threads->clone();
  m_modules = src.m_modules->clone();
  m_symcache = src.m_symcache->clone();
  util::unlock();
}

catch (...) {
  delete m_threads;
  delete m_modules;
  m_threads = NULL;
  m_modules = NULL;
  util::unlock();
}


process::~process()
{
  util::lock();
  delete m_threads;
  delete m_modules;
  delete m_symcache;

  m_threads = NULL;
  m_modules = NULL;
  m_symcache = NULL;
  util::unlock();
}


inline process* process::clone() const
{
  return new process(*this);
}


inline pid_t process::pid() const
{
  return m_pid;
}


process& process::operator=(const process &rval)
{
  if ( unlikely(this == &rval) )
    return *this;

  util::lock();
  try {
    m_pid = rval.m_pid;
    *m_threads = *rval.m_threads;
    *m_modules = *rval.m_modules;
    *m_symcache = *rval.m_symcache;

    util::unlock();
    return *this;
  }

  catch (...) {
    util::unlock();
    throw;
  }
}


u32 process::symbol_count() const
{
  u32 cnt = 0;
  for (i32 i = m_modules->size() - 1; likely(i >= 0); i--)
    cnt += m_modules->at(i)->size();

  return cnt;
}


inline u32 process::module_count() const
{
  return this->m_modules->size();
}


process& process::add_module(const i8 *path, mem_addr_t base)
{
  util::lock();
  symtab *tbl = NULL;
  try {
    tbl = new symtab(path, base);
    m_modules->add(tbl);
    util::unlock();
    return *this;
  }

  catch (...) {
    delete tbl;
    util::unlock();
    throw;
  }
}


const i8* process::lookup(mem_addr_t addr)
{
  const symbol *sym = cache_lookup(addr);
  if ( likely(sym != NULL) )
    return sym->name();

  for (u32 i = 0, sz = m_modules->size(); likely(i < sz); i++) {
    const i8 *retval = m_modules->at(i)->lookup(addr);

    if ( unlikely(retval != NULL) ) {
      cache_add(addr, retval);
      return retval;
    }
  }

  /* The address was not resolved */
  cache_add(addr, NULL);
  return NULL;
}


const i8* process::ilookup(mem_addr_t addr, mem_addr_t &base) const
{
  for (u32 i = 0, sz = m_modules->size(); likely(i < sz); i++) {
    const symtab *tbl = m_modules->at(i);

    if ( unlikely(tbl->exists(addr)) ) {
      base = tbl->base();
      return tbl->path();
    }
  }

  base = 0;
  return NULL;
}


inline u32 process::thread_count() const
{
  return m_threads->size();
}


thread* process::current_thread()
{
  util::lock();
  for (u32 i = 0, sz = m_threads->size(); likely(i < sz); i++) {
    thread *thr = m_threads->at(i);

    if ( unlikely(thr->is_current()) ) {
      util::unlock();
      return thr;
    }
  }

  thread *retval = NULL;
  try {
    retval = new thread;
    m_threads->add(retval);
    util::unlock();
    return retval;
  }

  catch (...) {
    delete retval;
    util::unlock();
    throw;
  }
}


thread* process::get_thread(pthread_t id) const
{
  util::lock();
  for (u32 i = 0, sz = m_threads->size(); likely(i < sz); i++) {
    thread *thr = m_threads->at(i);

    if ( unlikely(thr->is_current()) ) {
      util::unlock();
      return thr;
    }
  }

  util::unlock();
  return NULL;
}


thread* process::get_thread(const i8 *nm) const
{
  __D_ASSERT(nm != NULL);
  if ( unlikely(nm == NULL) )
    return NULL;

  util::lock();
  for (u32 i = 0, sz = m_threads->size(); likely(i < sz); i++) {
    thread *thr = m_threads->at(i);

    if ( unlikely(strcmp(thr->name(), nm) == 0) ) {
      util::unlock();
      return thr;
    }
  }

  util::unlock();
  return NULL;
}


thread* process::get_thread(u32 i) const
{
  try {
    util::lock();
    thread *retval = m_threads->at(i);
    util::unlock();
    return retval;
  }

  catch (...) {
    util::unlock();
    throw;
  }
}


process& process::cleanup_thread(pthread_t id)
{
  util::lock();
  for (u32 i = 0, sz = m_threads->size(); likely(i < sz); i++) {
    thread *thr = m_threads->at(i);

    if ( unlikely(thr->is_current()) ) {
      m_threads->remove(i);
      util::unlock();
      break;
    }
  }

  util::unlock();
  return *this;
}

}