src/monitor/ptrace/Portal.h

   1 #ifndef AESALON_MONITOR_PTRACE_PORTAL_H
   2 #define AESALON_MONITOR_PTRACE_PORTAL_H
   3
   4 #include <sys/types.h>
   5 #include <sys/user.h>
   6
   7 #include <vector>
   8
   9 #include "Breakpoint.h"
  10 #include "Types.h"
  11 #include "SignalObserver.h"
  12 #include "BreakpointObserver.h"
  13 #include "platform/MemoryAddress.h"
  14 #include "platform/ArgumentList.h"
  15 #include "misc/SmartPointer.h"
  16 #include "PTraceException.h"
  17 #include "asm/Register.h"
  18
  19 namespace Aesalon {
  20 namespace Monitor {
  21 namespace PTrace {
  22
  23 class Portal {
  24 protected:
  25     typedef std::vector<Misc::SmartPointer<Breakpoint> > breakpoint_list_t;
  26
  27     typedef std::vector<Misc::SmartPointer<SignalObserver> > signal_observer_list_t;
  28     typedef std::vector<Misc::SmartPointer<BreakpointObserver> > breakpoint_observer_list_t;
  29 private:
  30     /** The PID of the attached process. */
  31     pid_t pid;
  32
  33     /** The vector of breakpoints. */
  34     breakpoint_list_t breakpoint_list;
  35
  36     /** Adds a breakpoint onto the list.
  37         @param breakpoint The breakpoint to add.
  38     */
  39     void add_breakpoint(Misc::SmartPointer<Breakpoint> breakpoint) {
  40         breakpoint_list.push_back(breakpoint);
  41     }
  42
  43     signal_observer_list_t signal_observer_list;
  44
  45     breakpoint_observer_list_t breakpoint_observer_list;
  46
  47     Word libc_offset;
  48
  49     int wait_for_signal();
  50 public:
  51     /** Generic constructor for PTracePortal.
  52         @param argument_list The arguments to spawn the child with.
  53     */
  54     Portal(Misc::SmartPointer<Platform::ArgumentList> argument_list);
  55     /** Virtual destructor, does nothing. */
  56     virtual ~Portal() {}
  57
  58     /** Retrieve the value of a specific register.
  59         @param which The register to get the value of.
  60         @return The value of the specified register.
  61     */
  62     Platform::MemoryAddress get_register(ASM::Register which) const;
  63
  64     void set_register(ASM::Register which, Word new_value);
  65
  66     /** Read a Word of memory.
  67         @param address The address to read.
  68         @return The value at @a address.
  69     */
  70     Word read_memory(Platform::MemoryAddress address) const;
  71     /** Write a Word of memory.
  72         @param address The address to write to.
  73         @param value The value to write.
  74     */
  75     void write_memory(Platform::MemoryAddress address, Word value);
  76     /** Write a Byte of memory.
  77         @param address The address to write to.
  78         @param value The value to write.
  79     */
  80     void write_memory(Platform::MemoryAddress address, Byte value);
  81
  82     /** Attaches onto the PID @a pid. */
  83     void attach();
  84     /** Detaches from running program. */
  85     void detach();
  86
  87     /** Places a breakpoint at a specified address.
  88         @param address The address to place the breakpoint at.
  89         @return The ID of the newly-inserted breakpoint.
  90     */
  91     std::size_t place_breakpoint(Platform::MemoryAddress address);
  92
  93     void remove_breakpoint(Platform::MemoryAddress address);
  94
  95     /** Returns a breakpoint by iterator.
  96         @param which The breakpoint to find.
  97         @return A SmartPointer to the given breakpoint. Not valid if the breakpoint iterator does not exist.
  98     */
  99     Misc::SmartPointer<Breakpoint> get_breakpoint(breakpoint_list_t::size_type which) const {
 100         return breakpoint_list.at(which);
 101     }
 102
 103     Misc::SmartPointer<Breakpoint> get_breakpoint_by_id(std::size_t which) const;
 104
 105     /** Returns a breakpoint by address.
 106         @param address The address to search for.
 107         @return A SmartPointer to the given breakpoint. Not valid if no breakpoint exists at @a address.
 108     */
 109     Misc::SmartPointer<Breakpoint> get_breakpoint_by_address(Platform::MemoryAddress address) const;
 110
 111     void handle_breakpoint();
 112
 113     void handle_signal();
 114     /** Continues execution, with a given signal sent to the child.
 115         @param signal The signal to send; none if zero.
 116     */
 117     void continue_execution(int signal = 0);
 118     /** Tells the child to execute a single instruction. */
 119     void single_step();
 120
 121     void add_signal_observer(Misc::SmartPointer<SignalObserver> new_observer) {
 122         signal_observer_list.push_back(new_observer);
 123     }
 124     void add_breakpoint_observer(Misc::SmartPointer<BreakpointObserver> new_observer) {
 125         breakpoint_observer_list.push_back(new_observer);
 126     }
 127
 128     /** Reads the memory map in /proc for the child process to determine the address libc is lodaded into.
 129         @return The address of libc, or 0 if libc is not currently loaded.
 130     */
 131     Word get_libc_offset();
 132
 133     void wait_for_breakpoint(Misc::SmartPointer<Breakpoint> breakpoint);
 134 };
 135
 136 } // namespace PTrace
 137 } // namespace Monitor
 138 } // namespace Aesalon
 139
 140 #endif