BreakpointCommand.cc

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
#include "pedigree/kernel/debugger/commands/BreakpointCommand.h"
#include "pedigree/kernel/processor/Processor.h"
#include "pedigree/kernel/processor/types.h"
 
class DebuggerIO;
 
BreakpointCommand::BreakpointCommand() : DebuggerCommand() {}
 
BreakpointCommand::~BreakpointCommand() {}
 
void BreakpointCommand::autocomplete(const HugeStaticString& input, HugeStaticString& output) {
  output = "[ {0,1,2,3} {address,trigger,size,enable} [{parameter}] ]";
}
 
bool BreakpointCommand::execute(const HugeStaticString& input, HugeStaticString& output,
                                InterruptState& state, DebuggerIO* pScreen) {
  // Did we get any input?
  if (input == "breakpoint") {
    // Print out the current breakpoint status.
    output = "Current breakpoint status:\n";
    for (size_t i = 0; i < Processor::getDebugBreakpointCount(); i++) {
      DebugFlags::FaultType nFt;
      size_t nLen;
      bool bEnabled;
      uintptr_t nAddress = Processor::getDebugBreakpoint(i, nFt, nLen, bEnabled);
 
      const char* pFaultType = 0;
      switch (nFt) {
        case DebugFlags::InstructionFetch:
          pFaultType = "InstructionFetch";
          break;
        case DebugFlags::DataWrite:
          pFaultType = "DataWrite";
          break;
        case DebugFlags::IOReadWrite:
          pFaultType = "IOReadWrite";
          break;
        case DebugFlags::DataReadWrite:
          pFaultType = "DataReadWrite";
          break;
      }
 
      const char* pEnabled = "disabled";
      if (bEnabled)
        pEnabled = "enabled";
      output += i;
      output += ": 0x";
      output.append(nAddress, 16, sizeof(uintptr_t) * 2, '0');
      output += " \t";
      output.append(pFaultType);
      output += " \t";
      output.append(nLen);
      output += " \t";
      output.append(pEnabled);
      output += "\n";
    }
  } else {
    LargeStaticString inputCopy(input);
    // We expect a number.
    int32_t nBp = input.intValue();
    if (nBp < 0 || nBp >= static_cast<int32_t>(Processor::getDebugBreakpointCount())) {
      output = "Invalid breakpoint number.\n";
      return true;
    }
    // We expect a word - find the next space.
    bool bSpaceFound = false;
    for (size_t i = 0; i < inputCopy.length(); i++)
      if (inputCopy[i] == ' ') {
        inputCopy.stripFirst(i + 1);
        bSpaceFound = true;
        break;
      }
 
    if (!bSpaceFound) {
      output = "Command not recognised\n";
      return true;
    }
 
    NormalStaticString command;
    // Find another space - end of command.
    bSpaceFound = false;
    for (size_t i = 0; i < inputCopy.length(); i++)
      if (inputCopy[i] == ' ') {
        command = inputCopy.left(i);
        inputCopy.stripFirst(i + 1);
        bSpaceFound = true;
        break;
      }
 
    if (!bSpaceFound) {
      output = "Command not recognised\n";
      return true;
    }
 
    NormalStaticString argument;
    // Find another space - end of argument.
    bSpaceFound = false;
    for (size_t i = 0; i < inputCopy.length(); i++)
      if (inputCopy[i] == ' ') {
        argument = inputCopy.left(i);
        bSpaceFound = true;
        break;
      }
    if (!bSpaceFound)
      argument = inputCopy;
 
    if (argument.length() == 0) {
      output = "Parameter had zero length!\n";
      return true;
    }
 
    // Get the current breakpoint status.
    DebugFlags::FaultType nFaultType;
    size_t nLength;
    bool bEnabled;
    uintptr_t address = Processor::getDebugBreakpoint(nBp, nFaultType, nLength, bEnabled);
 
    if (command == "address") {
      address = argument.intValue();
      Processor::enableDebugBreakpoint(nBp, address, nFaultType, nLength);
    } else if (command == "trigger") {
    } else if (command == "enabled") {
      if (argument == "yes" || argument == "true") {
        Processor::enableDebugBreakpoint(nBp, address, nFaultType, nLength);
      } else {
        Processor::disableDebugBreakpoint(nBp);
      }
    } else {
      output = "Unrecognised command.\n";
      return true;
    }
  }
 
  return true;
}