40 #include <linux/kvm.h>
41 #include <sys/ioctl.h>
50 #include "debug/Checkpoint.hh"
51 #include "debug/Drain.hh"
52 #include "debug/Kvm.hh"
53 #include "debug/KvmIO.hh"
54 #include "debug/KvmRun.hh"
55 #include "params/BaseKvmCPU.hh"
60 #define PAGE_SIZE pageSize
69 dataPort(
name() +
".dcache_port", this),
70 instPort(
name() +
".icache_port", this),
71 alwaysSyncTC(params.alwaysSyncTC),
72 threadContextDirty(true),
74 vcpuID(-1), vcpuFD(-1), vcpuMMapSize(0),
75 _kvmRun(NULL), mmioRing(NULL),
76 pageSize(sysconf(_SC_PAGE_SIZE)),
77 tickEvent([this]{
tick(); },
"BaseKvmCPU tick",
80 perfControlledByTimer(params.usePerfOverflow),
81 hostFactor(params.hostFactor), stats(
this),
85 panic(
"KVM: Failed to determine host page size (%i)\n",
89 thread =
new SimpleThread(
this, 0, params.system, params.mmu,
90 params.isa[0], params.decoder[0]);
93 params.workload[0], params.mmu,
94 params.isa[0], params.decoder[0]);
98 threadContexts.push_back(tc);
120 const BaseKvmCPUParams &
p =
121 dynamic_cast<const BaseKvmCPUParams &
>(
params());
140 PROT_READ | PROT_WRITE, MAP_SHARED,
143 panic(
"KVM: Failed to map run data structure\n");
149 if (!
p.useCoalescedMMIO) {
150 inform(
"KVM: Coalesced MMIO disabled by config.\n");
151 }
else if (mmioOffset) {
152 inform(
"KVM: Coalesced IO available\n");
153 mmioRing = (
struct kvm_coalesced_mmio_ring *)(
156 inform(
"KVM: Coalesced not supported by host OS\n");
174 if (cpu->system->isAtomicMode()) {
175 Tick delay = sendAtomic(pkt);
179 if (pendingMMIOPkts.empty() && sendTimingReq(pkt)) {
182 pendingMMIOPkts.push(pkt);
192 DPRINTF(KvmIO,
"KVM: Finished timing request\n");
199 if (!(activeMMIOReqs || pendingMMIOPkts.size())) {
200 DPRINTF(KvmIO,
"KVM: Finished all outstanding timing requests\n");
201 cpu->finishMMIOPending();
209 DPRINTF(KvmIO,
"KVM: Retry for timing request\n");
211 assert(pendingMMIOPkts.size());
216 while (pendingMMIOPkts.size() && sendTimingReq(pendingMMIOPkts.front())) {
217 pendingMMIOPkts.pop();
239 const BaseKvmCPUParams &
p =
240 dynamic_cast<const BaseKvmCPUParams &
>(
params());
250 if (
p.usePerfOverflow) {
263 : statistics::
Group(parent),
265 "Number of instructions committed"),
267 "total number of KVM exits"),
269 "number of KVM entries to finalize pending operations"),
271 "exits due to signal delivery"),
273 "number of VM exits due to memory mapped IO"),
275 "number of coalesced memory mapped IO requests"),
277 "number of VM exits due to legacy IO"),
279 "number of VM exits due to wait for interrupt instructions"),
281 "number of interrupts delivered"),
282 ADD_STAT(numHypercalls, statistics::units::
Count::get(),
"number of hypercalls")
289 if (debug::Checkpoint) {
290 DPRINTF(Checkpoint,
"KVM: Serializing thread %i:\n", tid);
302 DPRINTF(Checkpoint,
"KVM: Unserialize thread %i:\n", tid);
316 DPRINTF(Drain,
"BaseKvmCPU::drain\n");
360 DPRINTF(Drain,
"KVM CPU is waiting for service completion, "
361 "requesting drain.\n");
366 DPRINTF(Drain,
"KVM CPU is waiting for timing accesses to complete, "
367 "requesting drain.\n");
372 DPRINTF(Drain,
"KVM CPU is waiting for service, requesting drain.\n");
376 panic(
"KVM: Unhandled CPU state in drain()\n");
421 warn(
"kvm CPU: notifyFork failed to close vcpuFD\n");
474 fatal(
"The KVM-based CPUs requires the memory system to be in the "
475 "'noncaching' mode.\n");
500 DPRINTF(
Kvm,
"ActivateContext %d\n", thread_num);
502 assert(thread_num == 0);
519 DPRINTF(
Kvm,
"SuspendContext %d\n", thread_num);
521 assert(thread_num == 0);
572 hack_once(
"Pretending totalOps is equivalent to totalInsts()\n");
579 inform(
"State dumping not implemented.");
600 const uint64_t nextInstEvent(
601 queue.empty() ?
MaxTick : queue.nextTick());
604 const Tick ticksToExecute(
617 if (ticksToExecute > 0)
620 DPRINTF(KvmRun,
"Entering KVM...\n");
628 delay =
kvmRun(ticksToExecute);
647 if (
_kvmRun->exit_reason != KVM_EXIT_INTR) {
664 panic(
"BaseKvmCPU entered tick() in an illegal state (%i)\n",
703 "Trying to run a KVM CPU in a forked child process. "
704 "This is not supported.\n");
705 DPRINTF(KvmRun,
"KVM: Executing for %i ticks\n", ticks);
711 DPRINTF(KvmRun,
"KVM: Delivering IO without full guest entry\n");
742 if (ticks < runTimer->resolution()) {
743 DPRINTF(KvmRun,
"KVM: Adjusting tick count (%i -> %i)\n",
774 const uint64_t hostCyclesExecuted(
getHostCycles() - baseCycles);
775 const uint64_t simCyclesExecuted(hostCyclesExecuted *
hostFactor);
777 ticksExecuted =
runTimer->ticksFromHostCycles(hostCyclesExecuted);
785 "KVM: Executed %i instructions in %i cycles "
786 "(%i ticks, sim cycles: %i).\n",
787 instsExecuted, hostCyclesExecuted, ticksExecuted, simCyclesExecuted);
799 if (
ioctl(KVM_NMI) == -1)
800 panic(
"KVM: Failed to deliver NMI to virtual CPU\n");
807 if (
ioctl(KVM_INTERRUPT, (
void *)&interrupt) == -1)
808 panic(
"KVM: Failed to deliver interrupt to virtual CPU\n");
814 if (
ioctl(KVM_GET_REGS, ®s) == -1)
815 panic(
"KVM: Failed to get guest registers\n");
821 if (
ioctl(KVM_SET_REGS, (
void *)®s) == -1)
822 panic(
"KVM: Failed to set guest registers\n");
828 if (
ioctl(KVM_GET_SREGS, ®s) == -1)
829 panic(
"KVM: Failed to get guest special registers\n");
835 if (
ioctl(KVM_SET_SREGS, (
void *)®s) == -1)
836 panic(
"KVM: Failed to set guest special registers\n");
843 panic(
"KVM: Failed to get guest FPU state\n");
850 panic(
"KVM: Failed to set guest FPU state\n");
857 #ifdef KVM_SET_ONE_REG
858 struct kvm_one_reg
reg;
862 if (
ioctl(KVM_SET_ONE_REG, &
reg) == -1) {
863 panic(
"KVM: Failed to set register (0x%x) value (errno: %i)\n",
867 panic(
"KVM_SET_ONE_REG is unsupported on this platform.\n");
874 #ifdef KVM_GET_ONE_REG
875 struct kvm_one_reg
reg;
879 if (
ioctl(KVM_GET_ONE_REG, &
reg) == -1) {
880 panic(
"KVM: Failed to get register (0x%x) value (errno: %i)\n",
884 panic(
"KVM_GET_ONE_REG is unsupported on this platform.\n");
891 #ifdef KVM_GET_ONE_REG
892 std::ostringstream
ss;
894 ss.setf(std::ios::hex, std::ios::basefield);
895 ss.setf(std::ios::showbase);
896 #define HANDLE_INTTYPE(len) \
897 case KVM_REG_SIZE_U ## len: { \
898 uint ## len ## _t value; \
899 getOneReg(id, &value); \
903 #define HANDLE_ARRAY(len) \
904 case KVM_REG_SIZE_U ## len: { \
905 uint8_t value[len / 8]; \
906 getOneReg(id, value); \
907 ccprintf(ss, "[0x%x", value[0]); \
908 for (int i = 1; i < len / 8; ++i) \
909 ccprintf(ss, ", 0x%x", value[i]); \
913 switch (
id & KVM_REG_SIZE_MASK) {
926 #undef HANDLE_INTTYPE
931 panic(
"KVM_GET_ONE_REG is unsupported on this platform.\n");
962 DPRINTF(KvmRun,
"handleKvmExit (exit_reason: %i)\n",
_kvmRun->exit_reason);
968 switch (
_kvmRun->exit_reason) {
969 case KVM_EXIT_UNKNOWN:
972 case KVM_EXIT_EXCEPTION:
983 case KVM_EXIT_HYPERCALL:
1001 DPRINTF(KvmIO,
"KVM: Handling MMIO (w: %u, addr: 0x%x, len: %u)\n",
1015 case KVM_EXIT_IRQ_WINDOW_OPEN:
1018 case KVM_EXIT_FAIL_ENTRY:
1026 case KVM_EXIT_INTERNAL_ERROR:
1027 panic(
"KVM: Internal error (suberror: %u)\n",
1032 panic(
"KVM: Unexpected exit (exit_reason: %u)\n",
_kvmRun->exit_reason);
1039 panic(
"KVM: Unhandled guest IO (dir: %i, size: %i, port: 0x%x, count: %i)\n",
1047 panic(
"KVM: Unhandled hypercall\n");
1053 warn(
"KVM: Unhandled IRQ window.\n");
1062 panic(
"KVM: Unknown error when starting vCPU (hw reason: 0x%llx)\n",
1063 _kvmRun->hw.hardware_exit_reason);
1070 panic(
"KVM: Got exception when starting vCPU "
1071 "(exception: %u, error_code: %u)\n",
1079 panic(
"KVM: Failed to enter virtualized mode (hw reason: 0x%llx)\n",
1080 _kvmRun->fail_entry.hardware_entry_failure_reason);
1089 RequestPtr mmio_req = std::make_shared<Request>(
1100 warn(
"Finalization of MMIO address failed: %s\n", fault->name());
1107 if (mmio_req->isLocalAccess()) {
1122 const Cycles ipr_delay = mmio_req->localAccessor(
tc, pkt);
1138 std::unique_ptr<
struct kvm_signal_mask, void(*)(
void *
p)>
1139 kvm_mask(
nullptr, [](
void *
p) {
operator delete(
p); });
1142 kvm_mask.reset((
struct kvm_signal_mask *)
operator new(
1143 sizeof(
struct kvm_signal_mask) + sizeof(*
mask)));
1147 assert(
sizeof(*
mask) >= 8);
1149 memcpy(kvm_mask->sigset,
mask, kvm_mask->len);
1152 if (
ioctl(KVM_SET_SIGNAL_MASK, (
void *)kvm_mask.get()) == -1)
1153 panic(
"KVM: Failed to set vCPU signal mask (errno: %i)\n",
1161 panic(
"KVM: CPU ioctl called before initialization\n");
1163 return ::ioctl(
vcpuFD, request, p1);
1172 DPRINTF(KvmIO,
"KVM: Flushing the coalesced MMIO ring buffer\n");
1178 struct kvm_coalesced_mmio &ent(
1181 DPRINTF(KvmIO,
"KVM: Handling coalesced MMIO (addr: 0x%x, len: %u)\n",
1182 ent.phys_addr, ent.len);
1185 ticks +=
doMMIOAccess(ent.phys_addr, ent.data, ent.len,
true);
1211 struct sigaction
sa;
1213 memset(&
sa, 0,
sizeof(
sa));
1215 sa.sa_flags = SA_SIGINFO | SA_RESTART;
1217 panic(
"KVM: Failed to setup vCPU timer signal handler\n");
1220 if (pthread_sigmask(SIG_BLOCK, NULL, &sigset) == -1)
1221 panic(
"KVM: Failed get signal mask\n");
1233 if (pthread_sigmask(SIG_SETMASK, &sigset, NULL) == -1)
1234 panic(
"KVM: Failed mask the KVM control signals\n");
1240 int discardedSignal;
1244 struct timespec timeout;
1246 timeout.tv_nsec = 0;
1249 sigemptyset(&sigset);
1250 sigaddset(&sigset, signum);
1253 discardedSignal = sigtimedwait(&sigset, NULL, &timeout);
1254 }
while (discardedSignal == -1 && errno == EINTR);
1256 if (discardedSignal == signum)
1258 else if (discardedSignal == -1 && errno == EAGAIN)
1261 panic(
"Unexpected return value from sigtimedwait: %i (errno: %i)\n",
1262 discardedSignal, errno);
1268 DPRINTF(
Kvm,
"Attaching cycle counter...\n");
1270 PERF_COUNT_HW_CPU_CYCLES);
1308 DPRINTF(Drain,
"tryDrain: Architecture code is not ready.\n");
1314 "tryDrain: CPU transitioned into the Idle state, drain done\n");
1318 DPRINTF(Drain,
"tryDrain: CPU not ready.\n");
1326 if (
ioctl(KVM_RUN) == -1) {
1328 panic(
"KVM: Failed to start virtual CPU (errno: %i)\n",
1354 PERF_COUNT_HW_INSTRUCTIONS);
RequestorID dataRequestorId() const
Reads this CPU's unique data requestor ID.
void init() override
init() is called after all C++ SimObjects have been created and all ports are connected.
void updateCycleCounters(CPUState state)
base method keeping track of cycle progression
gem5::BaseCPU::BaseCPUStats baseStats
ThreadID numThreads
Number of threads we're actually simulating (<= SMT_MAX_THREADS).
void startup() override
startup() is the final initialization call before simulation.
virtual void switchOut()
Prepare for another CPU to take over execution.
virtual void takeOverFrom(BaseCPU *cpu)
Load the state of a CPU from the previous CPU object, invoked on all new CPUs that are about to be sw...
std::vector< ThreadContext * > threadContexts
bool switchedOut() const
Determine if the CPU is switched out.
std::queue< PacketPtr > pendingMMIOPkts
Pending MMIO packets.
Status nextIOState() const
Returns next valid state after one or more IO accesses.
Tick submitIO(PacketPtr pkt)
Interface to send Atomic or Timing IO request.
void recvReqRetry() override
Called by the peer if sendTimingReq was called on this peer (causing recvTimingReq to be called on th...
bool recvTimingResp(PacketPtr pkt) override
Receive a timing response from the peer.
unsigned int activeMMIOReqs
Number of MMIO requests in flight.
virtual void dump() const
Dump the internal state to the terminal.
int vcpuFD
KVM vCPU file descriptor.
void finishMMIOPending()
Callback from KvmCPUPort to transition the CPU out of RunningMMIOPending when all timing requests hav...
Status _status
CPU run state.
uint64_t activeInstPeriod
Currently active instruction count breakpoint.
virtual void updateKvmState()=0
Update the KVM state from the current thread context.
struct kvm_coalesced_mmio_ring * mmioRing
Coalesced MMIO ring buffer.
virtual Tick handleKvmExitHypercall()
The guest requested a monitor service using a hypercall.
long vcpuID
KVM internal ID of the vCPU.
void drainResume() override
Resume execution after a successful drain.
void getSpecialRegisters(struct kvm_sregs ®s) const
virtual void updateThreadContext()=0
Update the current thread context with the KVM state.
void takeOverFrom(BaseCPU *cpu) override
Load the state of a CPU from the previous CPU object, invoked on all new CPUs that are about to be sw...
virtual uint64_t getHostCycles() const
Get the value of the hardware cycle counter in the guest.
Counter totalInsts() const override
void getOneReg(uint64_t id, void *addr) const
void init() override
init() is called after all C++ SimObjects have been created and all ports are connected.
const bool alwaysSyncTC
Be conservative and always synchronize the thread context on KVM entry/exit.
void suspendContext(ThreadID thread_num) override
Notify the CPU that the indicated context is now suspended.
virtual Tick handleKvmExitIRQWindowOpen()
The guest exited because an interrupt window was requested.
void setSignalMask(const sigset_t *mask)
Set the signal mask used in kvmRun()
void notifyFork() override
Notify a child process of a fork.
PerfKvmCounter hwCycles
Guest cycle counter.
int vcpuMMapSize
Size of MMAPed kvm_run area.
void syncKvmState()
Update the KVM if the thread context is dirty.
bool tryDrain()
Try to drain the CPU if a drain is pending.
void setRegisters(const struct kvm_regs ®s)
BaseKvmCPU(const BaseKvmCPUParams ¶ms)
virtual Tick handleKvmExitException()
An unhandled virtualization exception occured.
void kick() const
Force an exit from KVM.
@ Running
Running normally.
@ Idle
Context not scheduled in KVM.
@ RunningMMIOPending
Timing MMIO request in flight or stalled.
@ RunningService
Requiring service at the beginning of the next cycle.
@ RunningServiceCompletion
Service completion in progress.
void deallocateContext(ThreadID thread_num)
void getRegisters(struct kvm_regs ®s) const
Get/Set the register state of the guest vCPU.
void setupSignalHandler()
Setup a signal handler to catch the timer signal used to switch back to the monitor.
void setSpecialRegisters(const struct kvm_sregs ®s)
ThreadContext * getContext(int tn) override
Given a thread num get tho thread context for it.
virtual Tick handleKvmExitIO()
The guest performed a legacy IO request (out/inp on x86)
std::string getAndFormatOneReg(uint64_t id) const
Get and format one register for printout.
gem5::BaseKvmCPU::StatGroup stats
virtual Tick handleKvmExit()
Main kvmRun exit handler, calls the relevant handleKvmExit* depending on exit type.
void syncThreadContext()
Update a thread context if the KVM state is dirty with respect to the cached thread context.
void unserializeThread(CheckpointIn &cp, ThreadID tid) override
Unserialize one thread.
EventQueue * deviceEventQueue()
Get a pointer to the event queue owning devices.
DrainState drain() override
Draining is the process of clearing out the states of SimObjects.These are the SimObjects that are pa...
Tick doMMIOAccess(Addr paddr, void *data, int size, bool write)
Inject a memory mapped IO request into gem5.
void wakeup(ThreadID tid=0) override
void startup() override
startup() is the final initialization call before simulation.
Counter totalOps() const override
Tick flushCoalescedMMIO()
Service MMIO requests in the mmioRing.
EventFunctionWrapper tickEvent
bool perfControlledByTimer
Does the runTimer control the performance counters?
virtual Tick kvmRun(Tick ticks)
Request KVM to run the guest for a given number of ticks.
void setupInstStop()
Setup an instruction break if there is one pending.
bool discardPendingSignal(int signum) const
Discard a (potentially) pending signal.
virtual Tick kvmRunDrain()
Request the CPU to run until draining completes.
virtual Tick handleKvmExitFailEntry()
KVM failed to start the virtualized CPU.
void switchOut() override
Prepare for another CPU to take over execution.
void restartEqThread()
Thread-specific initialization.
void setupCounters()
Setup hardware performance counters.
void serializeThread(CheckpointOut &cp, ThreadID tid) const override
Serialize a single thread.
PerfKvmCounter hwInstructions
Guest instruction counter.
void setupInstCounter(uint64_t period=0)
Setup the guest instruction counter.
void activateContext(ThreadID thread_num) override
Notify the CPU that the indicated context is now active.
void tick()
Execute the CPU until the next event in the main event queue or until the guest needs service from ge...
virtual bool archIsDrained() const
Is the architecture specific code in a state that prevents draining?
struct kvm_run * _kvmRun
Pointer to the kvm_run structure used to communicate parameters with KVM.
void setOneReg(uint64_t id, const void *addr)
Get/Set single register using the KVM_(SET|GET)_ONE_REG API.
std::unique_ptr< BaseKvmTimer > runTimer
Timer used to force execution into the monitor after a specified number of simulation tick equivalent...
KVMCpuPort dataPort
Port for data requests.
SimpleThread * thread
A cached copy of a thread's state in the form of a SimpleThread object.
void setFPUState(const struct kvm_fpu &state)
virtual Tick handleKvmExitUnknown()
An unknown architecture dependent error occurred when starting the vCPU.
void getFPUState(struct kvm_fpu &state) const
Get/Set the guest FPU/vector state.
void haltContext(ThreadID thread_num) override
Notify the CPU that the indicated context is now halted.
bool kvmStateDirty
Is the KVM state dirty? Set to true to force an update of the KVM vCPU state upon the next call to kv...
void verifyMemoryMode() const override
Verify that the system is in a memory mode supported by the CPU.
bool threadContextDirty
Is the gem5 context dirty? Set to true to force an update of the KVM vCPU state upon the next call to...
const long pageSize
Cached page size of the host.
pthread_t vcpuThread
ID of the vCPU thread.
Counter ctrInsts
Number of instructions executed by the CPU.
float hostFactor
Host factor as specified in the configuration.
ThreadContext * tc
ThreadContext object, provides an interface for external objects to modify this thread's state.
virtual void ioctlRun()
Execute the KVM_RUN ioctl.
virtual void stutterPC(PCStateBase &pc) const =0
Modify a PCStatePtr's value so that its next PC is the current PC.
virtual Fault finalizePhysical(const RequestPtr &req, ThreadContext *tc, Mode mode) const
Tick clockEdge(Cycles cycles=Cycles(0)) const
Determine the tick when a cycle begins, by default the current one, but the argument also enables the...
Tick nextCycle() const
Based on the clock of the object, determine the start tick of the first cycle that is at least one cy...
Cycles ticksToCycles(Tick t) const
Cycles is a wrapper class for representing cycle counts, i.e.
int createVCPU(long vcpuID)
Create a new vCPU within a VM.
Kvm * kvm
Global KVM interface.
long allocVCPUID()
Allocate a new vCPU ID within the VM.
void cpuStartup()
VM CPU initialization code.
int getVCPUMMapSize() const
Get the size of the MMAPed parameter area used to communicate vCPU parameters between the kernel and ...
int capCoalescedMMIO() const
Check if coalesced MMIO is supported and which page in the MMAP'ed structure it stores requests in.
virtual std::string name() const
virtual PCStateBase * clone() const =0
A Packet is used to encapsulate a transfer between two objects in the memory system (e....
void dataStatic(T *p)
Set the data pointer to the following value that should not be freed.
PerfEvent counter configuration.
PerfKvmCounterConfig & disabled(bool val)
Don't start the performance counter automatically when attaching it.
PerfKvmCounterConfig & samplePeriod(uint64_t period)
Set the initial sample period (overflow count) of an event.
PerfKvmCounterConfig & exclude_hv(bool val)
Exclude the hyper visor (i.e., only include events from the guest system).
PerfKvmCounterConfig & pinned(bool val)
Force the group to be on the active all the time (i.e., disallow multiplexing).
PerfKvmCounterConfig & wakeupEvents(uint32_t events)
Set the number of samples that need to be triggered before reporting data as being available on the p...
PerfKvmCounterConfig & exclude_host(bool val)
Exclude the events from the host (i.e., only include events from the guest system).
uint64_t read() const
Read the current value of a counter.
void attach(PerfKvmCounterConfig &config, pid_t tid)
Attach a counter.
void detach()
Detach a counter from PerfEvent.
bool attached() const
Check if a counter is attached.
void enableSignals(pid_t tid, int signal)
Enable signal delivery to a thread on counter overflow.
void start()
Start counting.
void stop()
Stop counting.
PerfEvent based timer using the host's CPU cycle counter.
Timer based on standard POSIX timers.
@ UNCACHEABLE
The request is to an uncacheable address.
The SimpleThread object provides a combination of the ThreadState object and the ThreadContext interf...
ThreadContext * getTC()
Returns the pointer to this SimpleThread's ThreadContext.
void serialize(CheckpointOut &cp) const override
Serialize an object.
Status status() const override
void suspend() override
Set the status to Suspended.
void activate() override
Set the status to Active.
EventQueue comInstEventQueue
An instruction-based event queue.
void unserialize(CheckpointIn &cp) override
Unserialize an object.
KvmVM * getKvmVM() const
Get a pointer to the Kernel Virtual Machine (KVM) SimObject, if present.
bool bypassCaches() const
Should caches be bypassed?
ThreadContext is the external interface to all thread state for anything outside of the CPU.
virtual const PCStateBase & pcState() const =0
@ Halted
Permanently shut down.
@ Suspended
Temporarily inactive.
virtual Status status() const =0
virtual ContextID contextId() const =0
virtual BaseMMU * getMMUPtr()=0
#define KVM_KICK_SIGNAL
Signal to use to trigger exits from KVM.
#define ADD_STAT(n,...)
Convenience macro to add a stat to a statistics group.
void kvmInterrupt(const struct kvm_interrupt &interrupt)
Send a normal interrupt to the guest.
void kvmNonMaskableInterrupt()
Send a non-maskable interrupt to the guest.
int ioctl(int request, long p1) const
vCPU ioctl interface.
constexpr uint64_t mask(unsigned nbits)
Generate a 64-bit mask of 'nbits' 1s, right justified.
void signalDrainDone() const
Signal that an object is drained.
DrainState drainState() const
Return the current drain state of an object.
DrainState
Object drain/handover states.
@ Draining
Draining buffers pending serialization/handover.
@ Drained
Buffers drained, ready for serialization/handover.
void deschedule(Event &event)
EventQueue * eventQueue() const
bool scheduled() const
Determine if the current event is scheduled.
void schedule(Event &event, Tick when)
bool empty() const
Returns true if no events are queued.
static const Priority CPU_Tick_Pri
CPU ticks must come after other associated CPU events (such as writebacks).
#define panic(...)
This implements a cprintf based panic() function.
#define fatal_if(cond,...)
Conditional fatal macro that checks the supplied condition and only causes a fatal error if the condi...
#define fatal(...)
This implements a cprintf based fatal() function.
const Params & params() const
ProbePointArg< PacketInfo > Packet
Packet probe point.
double Counter
All counters are of 64-bit values.
Reference material can be found at the JEDEC website: UFS standard http://www.jedec....
std::shared_ptr< FaultBase > Fault
int16_t ThreadID
Thread index/ID type.
std::shared_ptr< Request > RequestPtr
static void onKickSignal(int signo, siginfo_t *si, void *data)
Dummy handler for KVM kick signals.
Tick curTick()
The universal simulation clock.
std::ostream CheckpointOut
uint64_t Addr
Address type This will probably be moved somewhere else in the near future.
bool FullSystem
The FullSystem variable can be used to determine the current mode of simulation.
uint64_t Tick
Tick count type.
EventQueue * curEventQueue()
constexpr decltype(nullptr) NoFault
statistics::Scalar numCycles
statistics::Scalar numExitSignal
StatGroup(statistics::Group *parent)
statistics::Scalar numHypercalls
statistics::Scalar committedInsts
statistics::Scalar numHalt
statistics::Scalar numVMHalfEntries
statistics::Scalar numMMIO
statistics::Scalar numCoalescedMMIO
statistics::Scalar numInterrupts
statistics::Scalar numVMExits
Tick lastSuspend
Last time suspend was called on this thread.
Tick lastActivate
Last time activate was called on this thread.
const std::string & name()