base.cc (9752:a152d7f114b8) base.cc (9753:b9a742cdd75a)
1/*
2 * Copyright (c) 2012 ARM Limited
3 * All rights reserved
4 *
5 * The license below extends only to copyright in the software and shall
6 * not be construed as granting a license to any other intellectual
7 * property including but not limited to intellectual property relating
8 * to a hardware implementation of the functionality of the software

--- 35 unchanged lines hidden (view full) ---

44
45#include <cerrno>
46#include <csignal>
47#include <ostream>
48
49#include "arch/utility.hh"
50#include "cpu/kvm/base.hh"
51#include "debug/Checkpoint.hh"
1/*
2 * Copyright (c) 2012 ARM Limited
3 * All rights reserved
4 *
5 * The license below extends only to copyright in the software and shall
6 * not be construed as granting a license to any other intellectual
7 * property including but not limited to intellectual property relating
8 * to a hardware implementation of the functionality of the software

--- 35 unchanged lines hidden (view full) ---

44
45#include <cerrno>
46#include <csignal>
47#include <ostream>
48
49#include "arch/utility.hh"
50#include "cpu/kvm/base.hh"
51#include "debug/Checkpoint.hh"
52#include "debug/Drain.hh"
52#include "debug/Kvm.hh"
53#include "debug/KvmIO.hh"
54#include "debug/KvmRun.hh"
55#include "params/BaseKvmCPU.hh"
56#include "sim/process.hh"
57#include "sim/system.hh"
58
53#include "debug/Kvm.hh"
54#include "debug/KvmIO.hh"
55#include "debug/KvmRun.hh"
56#include "params/BaseKvmCPU.hh"
57#include "sim/process.hh"
58#include "sim/system.hh"
59
60#include <signal.h>
61
59/* Used by some KVM macros */
60#define PAGE_SIZE pageSize
61
62volatile bool timerOverflowed = false;
63
64static void
65onTimerOverflow(int signo, siginfo_t *si, void *data)
66{

--- 9 unchanged lines hidden (view full) ---

76 threadContextDirty(true),
77 kvmStateDirty(false),
78 vcpuID(vm.allocVCPUID()), vcpuFD(-1), vcpuMMapSize(0),
79 _kvmRun(NULL), mmioRing(NULL),
80 pageSize(sysconf(_SC_PAGE_SIZE)),
81 tickEvent(*this),
82 perfControlledByTimer(params->usePerfOverflow),
83 hostFactor(params->hostFactor),
62/* Used by some KVM macros */
63#define PAGE_SIZE pageSize
64
65volatile bool timerOverflowed = false;
66
67static void
68onTimerOverflow(int signo, siginfo_t *si, void *data)
69{

--- 9 unchanged lines hidden (view full) ---

79 threadContextDirty(true),
80 kvmStateDirty(false),
81 vcpuID(vm.allocVCPUID()), vcpuFD(-1), vcpuMMapSize(0),
82 _kvmRun(NULL), mmioRing(NULL),
83 pageSize(sysconf(_SC_PAGE_SIZE)),
84 tickEvent(*this),
85 perfControlledByTimer(params->usePerfOverflow),
86 hostFactor(params->hostFactor),
87 drainManager(NULL),
84 ctrInsts(0)
85{
86 if (pageSize == -1)
87 panic("KVM: Failed to determine host page size (%i)\n",
88 errno);
89
90 thread = new SimpleThread(this, 0, params->system,
91 params->itb, params->dtb, params->isa[0]);
92 thread->setStatus(ThreadContext::Halted);
93 tc = thread->getTC();
94 threadContexts.push_back(tc);
95
96 setupCounters();
88 ctrInsts(0)
89{
90 if (pageSize == -1)
91 panic("KVM: Failed to determine host page size (%i)\n",
92 errno);
93
94 thread = new SimpleThread(this, 0, params->system,
95 params->itb, params->dtb, params->isa[0]);
96 thread->setStatus(ThreadContext::Halted);
97 tc = thread->getTC();
98 threadContexts.push_back(tc);
99
100 setupCounters();
97 setupSignalHandler();
98
99 if (params->usePerfOverflow)
100 runTimer.reset(new PerfKvmTimer(hwCycles,
101 KVM_TIMER_SIGNAL,
102 params->hostFactor,
103 params->clock));
104 else
105 runTimer.reset(new PosixKvmTimer(KVM_TIMER_SIGNAL, CLOCK_MONOTONIC,

--- 40 unchanged lines hidden (view full) ---

146 // Tell the VM that a CPU is about to start.
147 vm.cpuStartup();
148
149 // We can't initialize KVM CPUs in BaseKvmCPU::init() since we are
150 // not guaranteed that the parent KVM VM has initialized at that
151 // point. Initialize virtual CPUs here instead.
152 vcpuFD = vm.createVCPU(vcpuID);
153
101
102 if (params->usePerfOverflow)
103 runTimer.reset(new PerfKvmTimer(hwCycles,
104 KVM_TIMER_SIGNAL,
105 params->hostFactor,
106 params->clock));
107 else
108 runTimer.reset(new PosixKvmTimer(KVM_TIMER_SIGNAL, CLOCK_MONOTONIC,

--- 40 unchanged lines hidden (view full) ---

149 // Tell the VM that a CPU is about to start.
150 vm.cpuStartup();
151
152 // We can't initialize KVM CPUs in BaseKvmCPU::init() since we are
153 // not guaranteed that the parent KVM VM has initialized at that
154 // point. Initialize virtual CPUs here instead.
155 vcpuFD = vm.createVCPU(vcpuID);
156
157 // Setup signal handlers. This has to be done after the vCPU is
158 // created since it manipulates the vCPU signal mask.
159 setupSignalHandler();
160
154 // Map the KVM run structure */
155 vcpuMMapSize = kvm.getVCPUMMapSize();
156 _kvmRun = (struct kvm_run *)mmap(0, vcpuMMapSize,
157 PROT_READ | PROT_WRITE, MAP_SHARED,
158 vcpuFD, 0);
159 if (_kvmRun == MAP_FAILED)
160 panic("KVM: Failed to map run data structure\n");
161

--- 65 unchanged lines hidden (view full) ---

227void
228BaseKvmCPU::serializeThread(std::ostream &os, ThreadID tid)
229{
230 if (DTRACE(Checkpoint)) {
231 DPRINTF(Checkpoint, "KVM: Serializing thread %i:\n", tid);
232 dump();
233 }
234
161 // Map the KVM run structure */
162 vcpuMMapSize = kvm.getVCPUMMapSize();
163 _kvmRun = (struct kvm_run *)mmap(0, vcpuMMapSize,
164 PROT_READ | PROT_WRITE, MAP_SHARED,
165 vcpuFD, 0);
166 if (_kvmRun == MAP_FAILED)
167 panic("KVM: Failed to map run data structure\n");
168

--- 65 unchanged lines hidden (view full) ---

234void
235BaseKvmCPU::serializeThread(std::ostream &os, ThreadID tid)
236{
237 if (DTRACE(Checkpoint)) {
238 DPRINTF(Checkpoint, "KVM: Serializing thread %i:\n", tid);
239 dump();
240 }
241
235 // Update the thread context so we have something to serialize.
236 syncThreadContext();
237
238 assert(tid == 0);
239 assert(_status == Idle);
240 thread->serialize(os);
241}
242
243void
244BaseKvmCPU::unserializeThread(Checkpoint *cp, const std::string &section,
245 ThreadID tid)

--- 7 unchanged lines hidden (view full) ---

253}
254
255unsigned int
256BaseKvmCPU::drain(DrainManager *dm)
257{
258 if (switchedOut())
259 return 0;
260
242 assert(tid == 0);
243 assert(_status == Idle);
244 thread->serialize(os);
245}
246
247void
248BaseKvmCPU::unserializeThread(Checkpoint *cp, const std::string &section,
249 ThreadID tid)

--- 7 unchanged lines hidden (view full) ---

257}
258
259unsigned int
260BaseKvmCPU::drain(DrainManager *dm)
261{
262 if (switchedOut())
263 return 0;
264
261 DPRINTF(Kvm, "drain\n");
265 DPRINTF(Drain, "BaseKvmCPU::drain\n");
266 switch (_status) {
267 case Running:
268 // The base KVM code is normally ready when it is in the
269 // Running state, but the architecture specific code might be
270 // of a different opinion. This may happen when the CPU been
271 // notified of an event that hasn't been accepted by the vCPU
272 // yet.
273 if (!archIsDrained()) {
274 drainManager = dm;
275 return 1;
276 }
262
277
263 // De-schedule the tick event so we don't insert any more MMIOs
264 // into the system while it is draining.
265 if (tickEvent.scheduled())
266 deschedule(tickEvent);
278 // The state of the CPU is consistent, so we don't need to do
279 // anything special to drain it. We simply de-schedule the
280 // tick event and enter the Idle state to prevent nasty things
281 // like MMIOs from happening.
282 if (tickEvent.scheduled())
283 deschedule(tickEvent);
284 _status = Idle;
267
285
268 _status = Idle;
269 return 0;
286 /** FALLTHROUGH */
287 case Idle:
288 // Idle, no need to drain
289 assert(!tickEvent.scheduled());
290
291 // Sync the thread context here since we'll need it when we
292 // switch CPUs or checkpoint the CPU.
293 syncThreadContext();
294
295 return 0;
296
297 case RunningServiceCompletion:
298 // The CPU has just requested a service that was handled in
299 // the RunningService state, but the results have still not
300 // been reported to the CPU. Now, we /could/ probably just
301 // update the register state ourselves instead of letting KVM
302 // handle it, but that would be tricky. Instead, we enter KVM
303 // and let it do its stuff.
304 drainManager = dm;
305
306 DPRINTF(Drain, "KVM CPU is waiting for service completion, "
307 "requesting drain.\n");
308 return 1;
309
310 case RunningService:
311 // We need to drain since the CPU is waiting for service (e.g., MMIOs)
312 drainManager = dm;
313
314 DPRINTF(Drain, "KVM CPU is waiting for service, requesting drain.\n");
315 return 1;
316
317 default:
318 panic("KVM: Unhandled CPU state in drain()\n");
319 return 0;
320 }
270}
271
272void
273BaseKvmCPU::drainResume()
274{
275 assert(!tickEvent.scheduled());
276
277 // We might have been switched out. In that case, we don't need to

--- 14 unchanged lines hidden (view full) ---

292 }
293}
294
295void
296BaseKvmCPU::switchOut()
297{
298 DPRINTF(Kvm, "switchOut\n");
299
321}
322
323void
324BaseKvmCPU::drainResume()
325{
326 assert(!tickEvent.scheduled());
327
328 // We might have been switched out. In that case, we don't need to

--- 14 unchanged lines hidden (view full) ---

343 }
344}
345
346void
347BaseKvmCPU::switchOut()
348{
349 DPRINTF(Kvm, "switchOut\n");
350
300 // Make sure to update the thread context in case, the new CPU
301 // will need to access it.
302 syncThreadContext();
303
304 BaseCPU::switchOut();
305
306 // We should have drained prior to executing a switchOut, which
307 // means that the tick event shouldn't be scheduled and the CPU is
308 // idle.
309 assert(!tickEvent.scheduled());
310 assert(_status == Idle);
311}

--- 7 unchanged lines hidden (view full) ---

319
320 // We should have drained prior to executing a switchOut, which
321 // means that the tick event shouldn't be scheduled and the CPU is
322 // idle.
323 assert(!tickEvent.scheduled());
324 assert(_status == Idle);
325 assert(threadContexts.size() == 1);
326
351 BaseCPU::switchOut();
352
353 // We should have drained prior to executing a switchOut, which
354 // means that the tick event shouldn't be scheduled and the CPU is
355 // idle.
356 assert(!tickEvent.scheduled());
357 assert(_status == Idle);
358}

--- 7 unchanged lines hidden (view full) ---

366
367 // We should have drained prior to executing a switchOut, which
368 // means that the tick event shouldn't be scheduled and the CPU is
369 // idle.
370 assert(!tickEvent.scheduled());
371 assert(_status == Idle);
372 assert(threadContexts.size() == 1);
373
327 // The BaseCPU updated the thread context, make sure that we
328 // synchronize next time we enter start the CPU.
329 threadContextDirty = true;
374 // Force an update of the KVM state here instead of flagging the
375 // TC as dirty. This is not ideal from a performance point of
376 // view, but it makes debugging easier as it allows meaningful KVM
377 // state to be dumped before and after a takeover.
378 updateKvmState();
379 threadContextDirty = false;
330}
331
332void
333BaseKvmCPU::verifyMemoryMode() const
334{
335 if (!(system->isAtomicMode() && system->bypassCaches())) {
336 fatal("The KVM-based CPUs requires the memory system to be in the "
337 "'atomic_noncaching' mode.\n");

--- 93 unchanged lines hidden (view full) ---

431BaseKvmCPU::dump()
432{
433 inform("State dumping not implemented.");
434}
435
436void
437BaseKvmCPU::tick()
438{
380}
381
382void
383BaseKvmCPU::verifyMemoryMode() const
384{
385 if (!(system->isAtomicMode() && system->bypassCaches())) {
386 fatal("The KVM-based CPUs requires the memory system to be in the "
387 "'atomic_noncaching' mode.\n");

--- 93 unchanged lines hidden (view full) ---

481BaseKvmCPU::dump()
482{
483 inform("State dumping not implemented.");
484}
485
486void
487BaseKvmCPU::tick()
488{
439 assert(_status == Running);
489 Tick delay(0);
490 assert(_status != Idle);
440
491
441 DPRINTF(KvmRun, "Entering KVM...\n");
492 switch (_status) {
493 case RunningService:
494 // handleKvmExit() will determine the next state of the CPU
495 delay = handleKvmExit();
442
496
443 Tick ticksToExecute(mainEventQueue.nextTick() - curTick());
444 Tick ticksExecuted(kvmRun(ticksToExecute));
497 if (tryDrain())
498 _status = Idle;
499 break;
445
500
446 Tick delay(ticksExecuted + handleKvmExit());
501 case RunningServiceCompletion:
502 case Running: {
503 Tick ticksToExecute(mainEventQueue.nextTick() - curTick());
447
504
448 switch (_status) {
449 case Running:
450 schedule(tickEvent, clockEdge(ticksToCycles(delay)));
451 break;
505 // We might need to update the KVM state.
506 syncKvmState();
452
507
508 DPRINTF(KvmRun, "Entering KVM...\n");
509 if (drainManager) {
510 // Force an immediate exit from KVM after completing
511 // pending operations. The architecture-specific code
512 // takes care to run until it is in a state where it can
513 // safely be drained.
514 delay = kvmRunDrain();
515 } else {
516 delay = kvmRun(ticksToExecute);
517 }
518
519 // Entering into KVM implies that we'll have to reload the thread
520 // context from KVM if we want to access it. Flag the KVM state as
521 // dirty with respect to the cached thread context.
522 kvmStateDirty = true;
523
524 // Enter into the RunningService state unless the
525 // simulation was stopped by a timer.
526 if (_kvmRun->exit_reason != KVM_EXIT_INTR)
527 _status = RunningService;
528 else
529 _status = Running;
530
531 if (tryDrain())
532 _status = Idle;
533 } break;
534
453 default:
535 default:
454 /* The CPU is halted or waiting for an interrupt from a
455 * device. Don't start it. */
456 break;
536 panic("BaseKvmCPU entered tick() in an illegal state (%i)\n",
537 _status);
457 }
538 }
539
540 // Schedule a new tick if we are still running
541 if (_status != Idle)
542 schedule(tickEvent, clockEdge(ticksToCycles(delay)));
458}
459
543}
544
545Tick
546BaseKvmCPU::kvmRunDrain()
547{
548 // By default, the only thing we need to drain is a pending IO
549 // operation which assumes that we are in the
550 // RunningServiceCompletion state.
551 assert(_status == RunningServiceCompletion);
552
553 // Deliver the data from the pending IO operation and immediately
554 // exit.
555 return kvmRun(0);
556}
557
460uint64_t
461BaseKvmCPU::getHostCycles() const
462{
463 return hwCycles.read();
464}
465
466Tick
467BaseKvmCPU::kvmRun(Tick ticks)
468{
558uint64_t
559BaseKvmCPU::getHostCycles() const
560{
561 return hwCycles.read();
562}
563
564Tick
565BaseKvmCPU::kvmRun(Tick ticks)
566{
469 // We might need to update the KVM state.
470 syncKvmState();
471 // Entering into KVM implies that we'll have to reload the thread
472 // context from KVM if we want to access it. Flag the KVM state as
473 // dirty with respect to the cached thread context.
474 kvmStateDirty = true;
475
476 if (ticks < runTimer->resolution()) {
477 DPRINTF(KvmRun, "KVM: Adjusting tick count (%i -> %i)\n",
478 ticks, runTimer->resolution());
479 ticks = runTimer->resolution();
480 }
481
567 Tick ticksExecuted;
482 DPRINTF(KvmRun, "KVM: Executing for %i ticks\n", ticks);
483 timerOverflowed = false;
484
568 DPRINTF(KvmRun, "KVM: Executing for %i ticks\n", ticks);
569 timerOverflowed = false;
570
485 // Get hardware statistics after synchronizing contexts. The KVM
486 // state update might affect guest cycle counters.
487 uint64_t baseCycles(getHostCycles());
488 uint64_t baseInstrs(hwInstructions.read());
571 if (ticks == 0) {
572 // Settings ticks == 0 is a special case which causes an entry
573 // into KVM that finishes pending operations (e.g., IO) and
574 // then immediately exits.
575 DPRINTF(KvmRun, "KVM: Delivering IO without full guest entry\n");
489
576
490 // Arm the run timer and start the cycle timer if it isn't
491 // controlled by the overflow timer. Starting/stopping the cycle
492 // timer automatically starts the other perf timers as they are in
493 // the same counter group.
494 runTimer->arm(ticks);
495 if (!perfControlledByTimer)
496 hwCycles.start();
577 // This signal is always masked while we are executing in gem5
578 // and gets unmasked temporarily as soon as we enter into
579 // KVM. See setSignalMask() and setupSignalHandler().
580 raise(KVM_TIMER_SIGNAL);
497
581
498 if (ioctl(KVM_RUN) == -1) {
499 if (errno != EINTR)
500 panic("KVM: Failed to start virtual CPU (errno: %i)\n",
501 errno);
502 }
582 // Enter into KVM. KVM will check for signals after completing
583 // pending operations (IO). Since the KVM_TIMER_SIGNAL is
584 // pending, this forces an immediate exit into gem5 again. We
585 // don't bother to setup timers since this shouldn't actually
586 // execute any code in the guest.
587 ioctlRun();
503
588
504 runTimer->disarm();
505 if (!perfControlledByTimer)
506 hwCycles.stop();
589 // We always execute at least one cycle to prevent the
590 // BaseKvmCPU::tick() to be rescheduled on the same tick
591 // twice.
592 ticksExecuted = clockPeriod();
593 } else {
594 if (ticks < runTimer->resolution()) {
595 DPRINTF(KvmRun, "KVM: Adjusting tick count (%i -> %i)\n",
596 ticks, runTimer->resolution());
597 ticks = runTimer->resolution();
598 }
507
599
600 // Get hardware statistics after synchronizing contexts. The KVM
601 // state update might affect guest cycle counters.
602 uint64_t baseCycles(getHostCycles());
603 uint64_t baseInstrs(hwInstructions.read());
508
604
509 const uint64_t hostCyclesExecuted(getHostCycles() - baseCycles);
510 const uint64_t simCyclesExecuted(hostCyclesExecuted * hostFactor);
511 const uint64_t instsExecuted(hwInstructions.read() - baseInstrs);
512 const Tick ticksExecuted(runTimer->ticksFromHostCycles(hostCyclesExecuted));
605 // Arm the run timer and start the cycle timer if it isn't
606 // controlled by the overflow timer. Starting/stopping the cycle
607 // timer automatically starts the other perf timers as they are in
608 // the same counter group.
609 runTimer->arm(ticks);
610 if (!perfControlledByTimer)
611 hwCycles.start();
513
612
514 if (ticksExecuted < ticks &&
515 timerOverflowed &&
516 _kvmRun->exit_reason == KVM_EXIT_INTR) {
517 // TODO: We should probably do something clever here...
518 warn("KVM: Early timer event, requested %i ticks but got %i ticks.\n",
519 ticks, ticksExecuted);
613 ioctlRun();
614
615 runTimer->disarm();
616 if (!perfControlledByTimer)
617 hwCycles.stop();
618
619 // The timer signal may have been delivered after we exited
620 // from KVM. It will be pending in that case since it is
621 // masked when we aren't executing in KVM. Discard it to make
622 // sure we don't deliver it immediately next time we try to
623 // enter into KVM.
624 discardPendingSignal(KVM_TIMER_SIGNAL);
625
626 const uint64_t hostCyclesExecuted(getHostCycles() - baseCycles);
627 const uint64_t simCyclesExecuted(hostCyclesExecuted * hostFactor);
628 const uint64_t instsExecuted(hwInstructions.read() - baseInstrs);
629 ticksExecuted = runTimer->ticksFromHostCycles(hostCyclesExecuted);
630
631 if (ticksExecuted < ticks &&
632 timerOverflowed &&
633 _kvmRun->exit_reason == KVM_EXIT_INTR) {
634 // TODO: We should probably do something clever here...
635 warn("KVM: Early timer event, requested %i ticks but got %i ticks.\n",
636 ticks, ticksExecuted);
637 }
638
639 /* Update statistics */
640 numCycles += simCyclesExecuted;;
641 numInsts += instsExecuted;
642 ctrInsts += instsExecuted;
643 system->totalNumInsts += instsExecuted;
644
645 DPRINTF(KvmRun,
646 "KVM: Executed %i instructions in %i cycles "
647 "(%i ticks, sim cycles: %i).\n",
648 instsExecuted, hostCyclesExecuted, ticksExecuted, simCyclesExecuted);
520 }
521
649 }
650
522 /* Update statistics */
523 numCycles += simCyclesExecuted;;
524 ++numVMExits;
651 ++numVMExits;
525 numInsts += instsExecuted;
526 ctrInsts += instsExecuted;
527 system->totalNumInsts += instsExecuted;
528
652
529 DPRINTF(KvmRun, "KVM: Executed %i instructions in %i cycles (%i ticks, sim cycles: %i).\n",
530 instsExecuted, hostCyclesExecuted, ticksExecuted, simCyclesExecuted);
531
532 return ticksExecuted + flushCoalescedMMIO();
533}
534
535void
536BaseKvmCPU::kvmNonMaskableInterrupt()
537{
538 ++numInterrupts;
539 if (ioctl(KVM_NMI) == -1)

--- 155 unchanged lines hidden (view full) ---

695 updateKvmState();
696 threadContextDirty = false;
697}
698
699Tick
700BaseKvmCPU::handleKvmExit()
701{
702 DPRINTF(KvmRun, "handleKvmExit (exit_reason: %i)\n", _kvmRun->exit_reason);
653 return ticksExecuted + flushCoalescedMMIO();
654}
655
656void
657BaseKvmCPU::kvmNonMaskableInterrupt()
658{
659 ++numInterrupts;
660 if (ioctl(KVM_NMI) == -1)

--- 155 unchanged lines hidden (view full) ---

816 updateKvmState();
817 threadContextDirty = false;
818}
819
820Tick
821BaseKvmCPU::handleKvmExit()
822{
823 DPRINTF(KvmRun, "handleKvmExit (exit_reason: %i)\n", _kvmRun->exit_reason);
824 assert(_status == RunningService);
703
825
826 // Switch into the running state by default. Individual handlers
827 // can override this.
828 _status = Running;
704 switch (_kvmRun->exit_reason) {
705 case KVM_EXIT_UNKNOWN:
706 return handleKvmExitUnknown();
707
708 case KVM_EXIT_EXCEPTION:
709 return handleKvmExitException();
710
711 case KVM_EXIT_IO:
829 switch (_kvmRun->exit_reason) {
830 case KVM_EXIT_UNKNOWN:
831 return handleKvmExitUnknown();
832
833 case KVM_EXIT_EXCEPTION:
834 return handleKvmExitException();
835
836 case KVM_EXIT_IO:
837 _status = RunningServiceCompletion;
712 ++numIO;
713 return handleKvmExitIO();
714
715 case KVM_EXIT_HYPERCALL:
716 ++numHypercalls;
717 return handleKvmExitHypercall();
718
719 case KVM_EXIT_HLT:
720 /* The guest has halted and is waiting for interrupts */
721 DPRINTF(Kvm, "handleKvmExitHalt\n");
722 ++numHalt;
723
724 // Suspend the thread until the next interrupt arrives
725 thread->suspend();
726
727 // This is actually ignored since the thread is suspended.
728 return 0;
729
730 case KVM_EXIT_MMIO:
838 ++numIO;
839 return handleKvmExitIO();
840
841 case KVM_EXIT_HYPERCALL:
842 ++numHypercalls;
843 return handleKvmExitHypercall();
844
845 case KVM_EXIT_HLT:
846 /* The guest has halted and is waiting for interrupts */
847 DPRINTF(Kvm, "handleKvmExitHalt\n");
848 ++numHalt;
849
850 // Suspend the thread until the next interrupt arrives
851 thread->suspend();
852
853 // This is actually ignored since the thread is suspended.
854 return 0;
855
856 case KVM_EXIT_MMIO:
857 _status = RunningServiceCompletion;
731 /* Service memory mapped IO requests */
732 DPRINTF(KvmIO, "KVM: Handling MMIO (w: %u, addr: 0x%x, len: %u)\n",
733 _kvmRun->mmio.is_write,
734 _kvmRun->mmio.phys_addr, _kvmRun->mmio.len);
735
736 ++numMMIO;
737 return doMMIOAccess(_kvmRun->mmio.phys_addr, _kvmRun->mmio.data,
738 _kvmRun->mmio.len, _kvmRun->mmio.is_write);

--- 72 unchanged lines hidden (view full) ---

811 mmio_req.setPhys(paddr, size, Request::UNCACHEABLE, dataMasterId());
812
813 const MemCmd cmd(write ? MemCmd::WriteReq : MemCmd::ReadReq);
814 Packet pkt(&mmio_req, cmd);
815 pkt.dataStatic(data);
816 return dataPort.sendAtomic(&pkt);
817}
818
858 /* Service memory mapped IO requests */
859 DPRINTF(KvmIO, "KVM: Handling MMIO (w: %u, addr: 0x%x, len: %u)\n",
860 _kvmRun->mmio.is_write,
861 _kvmRun->mmio.phys_addr, _kvmRun->mmio.len);
862
863 ++numMMIO;
864 return doMMIOAccess(_kvmRun->mmio.phys_addr, _kvmRun->mmio.data,
865 _kvmRun->mmio.len, _kvmRun->mmio.is_write);

--- 72 unchanged lines hidden (view full) ---

938 mmio_req.setPhys(paddr, size, Request::UNCACHEABLE, dataMasterId());
939
940 const MemCmd cmd(write ? MemCmd::WriteReq : MemCmd::ReadReq);
941 Packet pkt(&mmio_req, cmd);
942 pkt.dataStatic(data);
943 return dataPort.sendAtomic(&pkt);
944}
945
946void
947BaseKvmCPU::setSignalMask(const sigset_t *mask)
948{
949 std::unique_ptr<struct kvm_signal_mask> kvm_mask;
950
951 if (mask) {
952 kvm_mask.reset((struct kvm_signal_mask *)operator new(
953 sizeof(struct kvm_signal_mask) + sizeof(*mask)));
954 // The kernel and the user-space headers have different ideas
955 // about the size of sigset_t. This seems like a massive hack,
956 // but is actually what qemu does.
957 assert(sizeof(*mask) >= 8);
958 kvm_mask->len = 8;
959 memcpy(kvm_mask->sigset, mask, kvm_mask->len);
960 }
961
962 if (ioctl(KVM_SET_SIGNAL_MASK, (void *)kvm_mask.get()) == -1)
963 panic("KVM: Failed to set vCPU signal mask (errno: %i)\n",
964 errno);
965}
966
819int
820BaseKvmCPU::ioctl(int request, long p1) const
821{
822 if (vcpuFD == -1)
823 panic("KVM: CPU ioctl called before initialization\n");
824
825 return ::ioctl(vcpuFD, request, p1);
826}

--- 30 unchanged lines hidden (view full) ---

857{
858 struct sigaction sa;
859
860 memset(&sa, 0, sizeof(sa));
861 sa.sa_sigaction = onTimerOverflow;
862 sa.sa_flags = SA_SIGINFO | SA_RESTART;
863 if (sigaction(KVM_TIMER_SIGNAL, &sa, NULL) == -1)
864 panic("KVM: Failed to setup vCPU signal handler\n");
967int
968BaseKvmCPU::ioctl(int request, long p1) const
969{
970 if (vcpuFD == -1)
971 panic("KVM: CPU ioctl called before initialization\n");
972
973 return ::ioctl(vcpuFD, request, p1);
974}

--- 30 unchanged lines hidden (view full) ---

1005{
1006 struct sigaction sa;
1007
1008 memset(&sa, 0, sizeof(sa));
1009 sa.sa_sigaction = onTimerOverflow;
1010 sa.sa_flags = SA_SIGINFO | SA_RESTART;
1011 if (sigaction(KVM_TIMER_SIGNAL, &sa, NULL) == -1)
1012 panic("KVM: Failed to setup vCPU signal handler\n");
1013
1014 sigset_t sigset;
1015 if (sigprocmask(SIG_BLOCK, NULL, &sigset) == -1)
1016 panic("KVM: Failed get signal mask\n");
1017
1018 // Request KVM to setup the same signal mask as we're currently
1019 // running with. We'll sometimes need to mask the KVM_TIMER_SIGNAL
1020 // to cause immediate exits from KVM after servicing IO
1021 // requests. See kvmRun().
1022 setSignalMask(&sigset);
1023
1024 // Mask the KVM_TIMER_SIGNAL so it isn't delivered unless we're
1025 // actually executing inside KVM.
1026 sigaddset(&sigset, KVM_TIMER_SIGNAL);
1027 if (sigprocmask(SIG_SETMASK, &sigset, NULL) == -1)
1028 panic("KVM: Failed mask the KVM timer signal\n");
865}
866
1029}
1030
1031bool
1032BaseKvmCPU::discardPendingSignal(int signum) const
1033{
1034 int discardedSignal;
1035
1036 // Setting the timeout to zero causes sigtimedwait to return
1037 // immediately.
1038 struct timespec timeout;
1039 timeout.tv_sec = 0;
1040 timeout.tv_nsec = 0;
1041
1042 sigset_t sigset;
1043 sigemptyset(&sigset);
1044 sigaddset(&sigset, signum);
1045
1046 do {
1047 discardedSignal = sigtimedwait(&sigset, NULL, &timeout);
1048 } while (discardedSignal == -1 && errno == EINTR);
1049
1050 if (discardedSignal == signum)
1051 return true;
1052 else if (discardedSignal == -1 && errno == EAGAIN)
1053 return false;
1054 else
1055 panic("Unexpected return value from sigtimedwait: %i (errno: %i)\n",
1056 discardedSignal, errno);
1057}
1058
867void
868BaseKvmCPU::setupCounters()
869{
870 DPRINTF(Kvm, "Attaching cycle counter...\n");
871 PerfKvmCounterConfig cfgCycles(PERF_TYPE_HARDWARE,
872 PERF_COUNT_HW_CPU_CYCLES);
873 cfgCycles.disabled(true)
874 .pinned(true);

--- 13 unchanged lines hidden (view full) ---

888
889 DPRINTF(Kvm, "Attaching instruction counter...\n");
890 PerfKvmCounterConfig cfgInstructions(PERF_TYPE_HARDWARE,
891 PERF_COUNT_HW_INSTRUCTIONS);
892 hwInstructions.attach(cfgInstructions,
893 0, // TID (0 => currentThread)
894 hwCycles);
895}
1059void
1060BaseKvmCPU::setupCounters()
1061{
1062 DPRINTF(Kvm, "Attaching cycle counter...\n");
1063 PerfKvmCounterConfig cfgCycles(PERF_TYPE_HARDWARE,
1064 PERF_COUNT_HW_CPU_CYCLES);
1065 cfgCycles.disabled(true)
1066 .pinned(true);

--- 13 unchanged lines hidden (view full) ---

1080
1081 DPRINTF(Kvm, "Attaching instruction counter...\n");
1082 PerfKvmCounterConfig cfgInstructions(PERF_TYPE_HARDWARE,
1083 PERF_COUNT_HW_INSTRUCTIONS);
1084 hwInstructions.attach(cfgInstructions,
1085 0, // TID (0 => currentThread)
1086 hwCycles);
1087}
1088
1089bool
1090BaseKvmCPU::tryDrain()
1091{
1092 if (!drainManager)
1093 return false;
1094
1095 if (!archIsDrained()) {
1096 DPRINTF(Drain, "tryDrain: Architecture code is not ready.\n");
1097 return false;
1098 }
1099
1100 if (_status == Idle || _status == Running) {
1101 DPRINTF(Drain,
1102 "tryDrain: CPU transitioned into the Idle state, drain done\n");
1103 drainManager->signalDrainDone();
1104 drainManager = NULL;
1105 return true;
1106 } else {
1107 DPRINTF(Drain, "tryDrain: CPU not ready.\n");
1108 return false;
1109 }
1110}
1111
1112void
1113BaseKvmCPU::ioctlRun()
1114{
1115 if (ioctl(KVM_RUN) == -1) {
1116 if (errno != EINTR)
1117 panic("KVM: Failed to start virtual CPU (errno: %i)\n",
1118 errno);
1119 }
1120}