9a47d75f9a
git-svn-id: https://www4.informatik.uni-erlangen.de/i4svn/danceos/trunk/devel/fail@1307 8c4709b5-6ec9-48aa-a5cd-a96041d1645a
202 lines
7.5 KiB
C++
202 lines
7.5 KiB
C++
#ifndef __BOCHS_CONTROLLER_HPP__
|
|
#define __BOCHS_CONTROLLER_HPP__
|
|
|
|
#define DEBUG
|
|
|
|
#include <string>
|
|
#include <cassert>
|
|
#include <iostream>
|
|
#include <iomanip>
|
|
#include <string.h>
|
|
|
|
#include "failbochs.hpp"
|
|
|
|
#include "../SimulatorController.hpp"
|
|
#include "../../controller/Event.hpp"
|
|
|
|
#include "../../../bochs/bochs.h"
|
|
#include "../../../bochs/cpu/cpu.h"
|
|
#include "../../../bochs/config.h"
|
|
#include "../../../bochs/iodev/iodev.h"
|
|
#include "../../../bochs/pc_system.h"
|
|
|
|
using namespace std;
|
|
|
|
namespace fi { class ExperimentFlow; }
|
|
|
|
/// Simulator Abstraction Layer namespace
|
|
namespace sal
|
|
{
|
|
|
|
/**
|
|
* \class BochsController
|
|
* Bochs-specific implementation of a SimulatorController.
|
|
*/
|
|
class BochsController : public SimulatorController
|
|
{
|
|
private:
|
|
fi::ExperimentFlow* m_CurrFlow; //!< Stores the current flow for save/restore-operations
|
|
#ifdef DEBUG
|
|
unsigned m_Regularity;
|
|
unsigned m_Counter;
|
|
std::ostream* m_pDest;
|
|
#endif
|
|
/**
|
|
* Static internal event handler for TimerEvents. This static function is
|
|
* called when a previously registered (Bochs) timer triggers. This function
|
|
* searches for the provided TimerEvent object within the EventList and
|
|
* fires such an event by calling \c fireActiveEvents().
|
|
* @param thisPtr a pointer to the TimerEvent-object triggered
|
|
*
|
|
* FIXME: Due to Bochs internal timer and ips-configuration related stuff,
|
|
* the simulator sometimes panics with "keyboard error:21" (see line
|
|
* 1777 in bios/rombios.c, function keyboard_init()) if a TimerEvent
|
|
* is added *before* the bios has been loaded and initialized. To
|
|
* reproduce this error, try adding a TimerEvent as the initial step
|
|
* in your experiment code and wait for it (addEventAndWait()).
|
|
*/
|
|
static void m_onTimerTrigger(void *thisPtr);
|
|
/**
|
|
* Registers a timer in the Bochs simulator. This timer fires \a TimerEvents
|
|
* to inform the corresponding experiment-flow. Note that the number of timers
|
|
* (in Bochs) is limited to \c BX_MAX_TIMERS (defaults to 64 in v2.4.6).
|
|
* @param pev a pointer to the (experiment flow-) allocated TimerEvent object,
|
|
* providing all required information to start the time, e.g. the
|
|
* timeout value.
|
|
* @return \c The unique id of the timer recently created. This id is carried
|
|
* along with the TimerEvent, @see getId(). On error, -1 is returned
|
|
* (e.g. because a timer with the same id is already existing)
|
|
*/
|
|
timer_id_t m_registerTimer(fi::TimerEvent* pev);
|
|
/**
|
|
* Deletes a timer. No further events will be triggered by the timer.
|
|
* @param pev a pointer to the TimerEvent-object to be removed
|
|
* @return \c true if the timer with \a pev->getId() has been removed
|
|
* successfully, \c false otherwise
|
|
*/
|
|
bool m_unregisterTimer(fi::TimerEvent* pev);
|
|
public:
|
|
// Initialize the controller.
|
|
BochsController();
|
|
~BochsController();
|
|
/* ********************************************************************
|
|
* Standard Event Handler API:
|
|
* ********************************************************************/
|
|
/**
|
|
* Instruction pointer modification handler. This method is called (from
|
|
* the Breakpoints aspect) every time when the Bochs-internal IP changes.
|
|
* @param instrPtr the new instruction pointer
|
|
* @param address_space the address space the CPU is currently in
|
|
*/
|
|
void onInstrPtrChanged(address_t instrPtr, address_t address_space);
|
|
/**
|
|
* I/O port communication handler. This method is called (from
|
|
* the IOPortCom aspect) every time when Bochs performs a port I/O operation.
|
|
* @param data the data transmitted
|
|
* @param port the port it was transmitted on
|
|
* @param out true if the I/O traffic has been outbound, false otherwise
|
|
*/
|
|
void onIOPortEvent(unsigned char data, unsigned port, bool out);
|
|
/**
|
|
* This method is called when an experiment flow adds a new event by
|
|
* calling \c simulator.addEvent(pev) or \c simulator.addEventAndWait(pev).
|
|
* More specifically, the event will be added to the event-list first
|
|
* (buffer-list, to be precise) and then this event handler is called.
|
|
* @param pev the event which has been added
|
|
* @return You should return \c true to continue and \c false to prevent
|
|
* the addition of the event \a pev.
|
|
*/
|
|
bool onEventAddition(fi::BaseEvent* pev);
|
|
/**
|
|
* This method is called when an experiment flow removes an event from
|
|
* the event-management by calling \c removeEvent(prev), \c clearEvents()
|
|
* or by deleting a complete flow (\c removeFlow). More specifically,
|
|
* this event handler will be called *before* the event is actually deleted.
|
|
* @param pev the event to be deleted when returning from the event handler
|
|
*/
|
|
void onEventDeletion(fi::BaseEvent* pev);
|
|
/**
|
|
* This method is called when an previously added event is about to be
|
|
* triggered by the simulator-backend. More specifically, this event handler
|
|
* will be called *before* the event is actually triggered, i.e. before the
|
|
* corresponding coroutine is toggled.
|
|
* @param pev the event to be triggered when returning from the event handler
|
|
*/
|
|
void onEventTrigger(fi::BaseEvent* pev);
|
|
/* ********************************************************************
|
|
* Simulator Controller & Access API:
|
|
* ********************************************************************/
|
|
/**
|
|
* Save simulator state.
|
|
* @param path Location to store state information
|
|
*/
|
|
void save(const string& path);
|
|
/**
|
|
* Save finished: Callback from Simulator
|
|
*/
|
|
void saveDone();
|
|
/**
|
|
* Restore simulator state. Clears all Events.
|
|
* @param path Location to previously saved state information
|
|
*/
|
|
void restore(const string& path);
|
|
/**
|
|
* Restore finished: Callback from Simulator
|
|
*/
|
|
void restoreDone();
|
|
/**
|
|
* Reboot simulator. Clears all Events.
|
|
*/
|
|
void reboot();
|
|
/**
|
|
* Reboot finished: Callback from Simulator
|
|
*/
|
|
void rebootDone();
|
|
/**
|
|
* Fire an interrupt.
|
|
* @param irq Interrupt to be fired
|
|
*/
|
|
void fireInterrupt(unsigned irq);
|
|
/**
|
|
* Fire done: Callback from Simulator
|
|
*/
|
|
void fireInterruptDone();
|
|
#ifdef DEBUG
|
|
/**
|
|
* Enables instruction pointer debugging output.
|
|
* @param regularity the output regularity; 1 to display every
|
|
* instruction pointer, 0 to disable
|
|
* @param dest specifies the output destition; defaults to \c std::cout
|
|
*/
|
|
void dbgEnableInstrPtrOutput(unsigned regularity, std::ostream* dest = &cout);
|
|
#endif
|
|
/* ********************************************************************
|
|
* BochsController-specific (not implemented in SimulatorController!):
|
|
* ********************************************************************/
|
|
/**
|
|
* Retrieves the textual description (mnemonic) for the current
|
|
* instruction. The format of the returned string is Bochs-specific.
|
|
* @return the mnemonic of the current instruction whose address
|
|
* is given by \c Register::getInstructionPointer(). On
|
|
* errors, the returned string is empty
|
|
*/
|
|
const std::string& getMnemonic() const
|
|
{
|
|
static std::string str;
|
|
bxICacheEntry_c* pEntry = BX_CPU(0)->getICacheEntry();
|
|
assert(pEntry != NULL && "FATAL ERROR: Bochs internal function returned NULL (not expected)!");
|
|
bxInstruction_c* pInstr = pEntry->i;
|
|
assert(pInstr != NULL && "FATAL ERROR: Bochs internal member was NULL (not expected)!");
|
|
const char* pszName = get_bx_opcode_name(pInstr->getIaOpcode());
|
|
if (pszName != NULL)
|
|
str = pszName;
|
|
else
|
|
str.clear();
|
|
return str;
|
|
}
|
|
};
|
|
|
|
} // end-of-namespace: sal
|
|
|
|
#endif /* __BOCHS_CONTROLLER_HPP__ */
|