base.cc revision 12749
19651SAndreas.Sandberg@ARM.com/* 212284Sjose.marinho@arm.com * Copyright (c) 2012, 2015, 2017 ARM Limited 39651SAndreas.Sandberg@ARM.com * All rights reserved 49651SAndreas.Sandberg@ARM.com * 59651SAndreas.Sandberg@ARM.com * The license below extends only to copyright in the software and shall 69651SAndreas.Sandberg@ARM.com * not be construed as granting a license to any other intellectual 79651SAndreas.Sandberg@ARM.com * property including but not limited to intellectual property relating 89651SAndreas.Sandberg@ARM.com * to a hardware implementation of the functionality of the software 99651SAndreas.Sandberg@ARM.com * licensed hereunder. You may use the software subject to the license 109651SAndreas.Sandberg@ARM.com * terms below provided that you ensure that this notice is replicated 119651SAndreas.Sandberg@ARM.com * unmodified and in its entirety in all distributions of the software, 129651SAndreas.Sandberg@ARM.com * modified or unmodified, in source code or in binary form. 139651SAndreas.Sandberg@ARM.com * 149651SAndreas.Sandberg@ARM.com * Redistribution and use in source and binary forms, with or without 159651SAndreas.Sandberg@ARM.com * modification, are permitted provided that the following conditions are 169651SAndreas.Sandberg@ARM.com * met: redistributions of source code must retain the above copyright 179651SAndreas.Sandberg@ARM.com * notice, this list of conditions and the following disclaimer; 189651SAndreas.Sandberg@ARM.com * redistributions in binary form must reproduce the above copyright 199651SAndreas.Sandberg@ARM.com * notice, this list of conditions and the following disclaimer in the 209651SAndreas.Sandberg@ARM.com * documentation and/or other materials provided with the distribution; 219651SAndreas.Sandberg@ARM.com * neither the name of the copyright holders nor the names of its 229651SAndreas.Sandberg@ARM.com * contributors may be used to endorse or promote products derived from 239651SAndreas.Sandberg@ARM.com * this software without specific prior written permission. 249651SAndreas.Sandberg@ARM.com * 259651SAndreas.Sandberg@ARM.com * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 269651SAndreas.Sandberg@ARM.com * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 279651SAndreas.Sandberg@ARM.com * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 289651SAndreas.Sandberg@ARM.com * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 299651SAndreas.Sandberg@ARM.com * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 309651SAndreas.Sandberg@ARM.com * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 319651SAndreas.Sandberg@ARM.com * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 329651SAndreas.Sandberg@ARM.com * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 339651SAndreas.Sandberg@ARM.com * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 349651SAndreas.Sandberg@ARM.com * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 359651SAndreas.Sandberg@ARM.com * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 369651SAndreas.Sandberg@ARM.com * 379651SAndreas.Sandberg@ARM.com * Authors: Andreas Sandberg 389651SAndreas.Sandberg@ARM.com */ 399651SAndreas.Sandberg@ARM.com 4011793Sbrandon.potter@amd.com#include "cpu/kvm/base.hh" 4111793Sbrandon.potter@amd.com 429651SAndreas.Sandberg@ARM.com#include <linux/kvm.h> 439651SAndreas.Sandberg@ARM.com#include <sys/ioctl.h> 449651SAndreas.Sandberg@ARM.com#include <sys/mman.h> 459651SAndreas.Sandberg@ARM.com#include <unistd.h> 469651SAndreas.Sandberg@ARM.com 479651SAndreas.Sandberg@ARM.com#include <cerrno> 489651SAndreas.Sandberg@ARM.com#include <csignal> 499651SAndreas.Sandberg@ARM.com#include <ostream> 509651SAndreas.Sandberg@ARM.com 519760Sandreas@sandberg.pp.se#include "arch/mmapped_ipr.hh" 529651SAndreas.Sandberg@ARM.com#include "arch/utility.hh" 539683Sandreas@sandberg.pp.se#include "debug/Checkpoint.hh" 549753Sandreas@sandberg.pp.se#include "debug/Drain.hh" 559651SAndreas.Sandberg@ARM.com#include "debug/Kvm.hh" 569651SAndreas.Sandberg@ARM.com#include "debug/KvmIO.hh" 579651SAndreas.Sandberg@ARM.com#include "debug/KvmRun.hh" 589651SAndreas.Sandberg@ARM.com#include "params/BaseKvmCPU.hh" 599651SAndreas.Sandberg@ARM.com#include "sim/process.hh" 609651SAndreas.Sandberg@ARM.com#include "sim/system.hh" 619651SAndreas.Sandberg@ARM.com 629651SAndreas.Sandberg@ARM.com/* Used by some KVM macros */ 639651SAndreas.Sandberg@ARM.com#define PAGE_SIZE pageSize 649651SAndreas.Sandberg@ARM.com 659651SAndreas.Sandberg@ARM.comBaseKvmCPU::BaseKvmCPU(BaseKvmCPUParams *params) 669651SAndreas.Sandberg@ARM.com : BaseCPU(params), 6711839SCurtis.Dunham@arm.com vm(*params->system->getKvmVM()), 689651SAndreas.Sandberg@ARM.com _status(Idle), 699651SAndreas.Sandberg@ARM.com dataPort(name() + ".dcache_port", this), 709651SAndreas.Sandberg@ARM.com instPort(name() + ".icache_port", this), 7111399Sandreas.sandberg@arm.com alwaysSyncTC(params->alwaysSyncTC), 729652SAndreas.Sandberg@ARM.com threadContextDirty(true), 739652SAndreas.Sandberg@ARM.com kvmStateDirty(false), 749651SAndreas.Sandberg@ARM.com vcpuID(vm.allocVCPUID()), vcpuFD(-1), vcpuMMapSize(0), 759651SAndreas.Sandberg@ARM.com _kvmRun(NULL), mmioRing(NULL), 769651SAndreas.Sandberg@ARM.com pageSize(sysconf(_SC_PAGE_SIZE)), 7712128Sspwilson2@wisc.edu tickEvent([this]{ tick(); }, "BaseKvmCPU tick", 7812128Sspwilson2@wisc.edu false, Event::CPU_Tick_Pri), 799892Sandreas@sandberg.pp.se activeInstPeriod(0), 809655SAndreas.Sandberg@ARM.com perfControlledByTimer(params->usePerfOverflow), 819752Sandreas@sandberg.pp.se hostFactor(params->hostFactor), 829752Sandreas@sandberg.pp.se ctrInsts(0) 839651SAndreas.Sandberg@ARM.com{ 849651SAndreas.Sandberg@ARM.com if (pageSize == -1) 859651SAndreas.Sandberg@ARM.com panic("KVM: Failed to determine host page size (%i)\n", 869651SAndreas.Sandberg@ARM.com errno); 879651SAndreas.Sandberg@ARM.com 8810553Salexandru.dutu@amd.com if (FullSystem) 8910553Salexandru.dutu@amd.com thread = new SimpleThread(this, 0, params->system, params->itb, params->dtb, 9010553Salexandru.dutu@amd.com params->isa[0]); 9110553Salexandru.dutu@amd.com else 9210553Salexandru.dutu@amd.com thread = new SimpleThread(this, /* thread_num */ 0, params->system, 9310553Salexandru.dutu@amd.com params->workload[0], params->itb, 9410553Salexandru.dutu@amd.com params->dtb, params->isa[0]); 9510553Salexandru.dutu@amd.com 969651SAndreas.Sandberg@ARM.com thread->setStatus(ThreadContext::Halted); 979651SAndreas.Sandberg@ARM.com tc = thread->getTC(); 989651SAndreas.Sandberg@ARM.com threadContexts.push_back(tc); 999651SAndreas.Sandberg@ARM.com} 1009651SAndreas.Sandberg@ARM.com 1019651SAndreas.Sandberg@ARM.comBaseKvmCPU::~BaseKvmCPU() 1029651SAndreas.Sandberg@ARM.com{ 1039651SAndreas.Sandberg@ARM.com if (_kvmRun) 1049651SAndreas.Sandberg@ARM.com munmap(_kvmRun, vcpuMMapSize); 1059651SAndreas.Sandberg@ARM.com close(vcpuFD); 1069651SAndreas.Sandberg@ARM.com} 1079651SAndreas.Sandberg@ARM.com 1089651SAndreas.Sandberg@ARM.comvoid 1099651SAndreas.Sandberg@ARM.comBaseKvmCPU::init() 1109651SAndreas.Sandberg@ARM.com{ 1119651SAndreas.Sandberg@ARM.com BaseCPU::init(); 1129651SAndreas.Sandberg@ARM.com 1139651SAndreas.Sandberg@ARM.com if (numThreads != 1) 1149651SAndreas.Sandberg@ARM.com fatal("KVM: Multithreading not supported"); 1159651SAndreas.Sandberg@ARM.com 1169651SAndreas.Sandberg@ARM.com tc->initMemProxies(tc); 1179651SAndreas.Sandberg@ARM.com 1189651SAndreas.Sandberg@ARM.com // initialize CPU, including PC 1199651SAndreas.Sandberg@ARM.com if (FullSystem && !switchedOut()) 1209651SAndreas.Sandberg@ARM.com TheISA::initCPU(tc, tc->contextId()); 1219651SAndreas.Sandberg@ARM.com} 1229651SAndreas.Sandberg@ARM.com 1239651SAndreas.Sandberg@ARM.comvoid 1249651SAndreas.Sandberg@ARM.comBaseKvmCPU::startup() 1259651SAndreas.Sandberg@ARM.com{ 1269690Sandreas@sandberg.pp.se const BaseKvmCPUParams * const p( 1279690Sandreas@sandberg.pp.se dynamic_cast<const BaseKvmCPUParams *>(params())); 1289690Sandreas@sandberg.pp.se 12911363Sandreas@sandberg.pp.se Kvm &kvm(*vm.kvm); 1309651SAndreas.Sandberg@ARM.com 1319651SAndreas.Sandberg@ARM.com BaseCPU::startup(); 1329651SAndreas.Sandberg@ARM.com 1339651SAndreas.Sandberg@ARM.com assert(vcpuFD == -1); 1349651SAndreas.Sandberg@ARM.com 1359651SAndreas.Sandberg@ARM.com // Tell the VM that a CPU is about to start. 1369651SAndreas.Sandberg@ARM.com vm.cpuStartup(); 1379651SAndreas.Sandberg@ARM.com 1389651SAndreas.Sandberg@ARM.com // We can't initialize KVM CPUs in BaseKvmCPU::init() since we are 1399651SAndreas.Sandberg@ARM.com // not guaranteed that the parent KVM VM has initialized at that 1409651SAndreas.Sandberg@ARM.com // point. Initialize virtual CPUs here instead. 1419651SAndreas.Sandberg@ARM.com vcpuFD = vm.createVCPU(vcpuID); 1429651SAndreas.Sandberg@ARM.com 1439651SAndreas.Sandberg@ARM.com // Map the KVM run structure */ 1449651SAndreas.Sandberg@ARM.com vcpuMMapSize = kvm.getVCPUMMapSize(); 1459651SAndreas.Sandberg@ARM.com _kvmRun = (struct kvm_run *)mmap(0, vcpuMMapSize, 1469651SAndreas.Sandberg@ARM.com PROT_READ | PROT_WRITE, MAP_SHARED, 1479651SAndreas.Sandberg@ARM.com vcpuFD, 0); 1489651SAndreas.Sandberg@ARM.com if (_kvmRun == MAP_FAILED) 1499651SAndreas.Sandberg@ARM.com panic("KVM: Failed to map run data structure\n"); 1509651SAndreas.Sandberg@ARM.com 1519651SAndreas.Sandberg@ARM.com // Setup a pointer to the MMIO ring buffer if coalesced MMIO is 1529651SAndreas.Sandberg@ARM.com // available. The offset into the KVM's communication page is 1539651SAndreas.Sandberg@ARM.com // provided by the coalesced MMIO capability. 1549651SAndreas.Sandberg@ARM.com int mmioOffset(kvm.capCoalescedMMIO()); 1559690Sandreas@sandberg.pp.se if (!p->useCoalescedMMIO) { 1569690Sandreas@sandberg.pp.se inform("KVM: Coalesced MMIO disabled by config.\n"); 1579690Sandreas@sandberg.pp.se } else if (mmioOffset) { 1589651SAndreas.Sandberg@ARM.com inform("KVM: Coalesced IO available\n"); 1599651SAndreas.Sandberg@ARM.com mmioRing = (struct kvm_coalesced_mmio_ring *)( 1609651SAndreas.Sandberg@ARM.com (char *)_kvmRun + (mmioOffset * pageSize)); 1619651SAndreas.Sandberg@ARM.com } else { 1629651SAndreas.Sandberg@ARM.com inform("KVM: Coalesced not supported by host OS\n"); 1639651SAndreas.Sandberg@ARM.com } 1649732Sandreas@sandberg.pp.se 1659732Sandreas@sandberg.pp.se thread->startup(); 16610073Sandreas@sandberg.pp.se 16710073Sandreas@sandberg.pp.se Event *startupEvent( 16812085Sspwilson2@wisc.edu new EventFunctionWrapper([this]{ startupThread(); }, name(), true)); 16910073Sandreas@sandberg.pp.se schedule(startupEvent, curTick()); 17010073Sandreas@sandberg.pp.se} 17110073Sandreas@sandberg.pp.se 17211629Smichael.lebeane@amd.comBaseKvmCPU::Status 17311629Smichael.lebeane@amd.comBaseKvmCPU::KVMCpuPort::nextIOState() const 17411629Smichael.lebeane@amd.com{ 17511629Smichael.lebeane@amd.com return (activeMMIOReqs || pendingMMIOPkts.size()) 17611629Smichael.lebeane@amd.com ? RunningMMIOPending : RunningServiceCompletion; 17711629Smichael.lebeane@amd.com} 17811629Smichael.lebeane@amd.com 17911629Smichael.lebeane@amd.comTick 18011629Smichael.lebeane@amd.comBaseKvmCPU::KVMCpuPort::submitIO(PacketPtr pkt) 18111629Smichael.lebeane@amd.com{ 18211629Smichael.lebeane@amd.com if (cpu->system->isAtomicMode()) { 18311629Smichael.lebeane@amd.com Tick delay = sendAtomic(pkt); 18411629Smichael.lebeane@amd.com delete pkt; 18511629Smichael.lebeane@amd.com return delay; 18611629Smichael.lebeane@amd.com } else { 18711629Smichael.lebeane@amd.com if (pendingMMIOPkts.empty() && sendTimingReq(pkt)) { 18811629Smichael.lebeane@amd.com activeMMIOReqs++; 18911629Smichael.lebeane@amd.com } else { 19011629Smichael.lebeane@amd.com pendingMMIOPkts.push(pkt); 19111629Smichael.lebeane@amd.com } 19211629Smichael.lebeane@amd.com // Return value is irrelevant for timing-mode accesses. 19311629Smichael.lebeane@amd.com return 0; 19411629Smichael.lebeane@amd.com } 19511629Smichael.lebeane@amd.com} 19611629Smichael.lebeane@amd.com 19711629Smichael.lebeane@amd.combool 19811629Smichael.lebeane@amd.comBaseKvmCPU::KVMCpuPort::recvTimingResp(PacketPtr pkt) 19911629Smichael.lebeane@amd.com{ 20011629Smichael.lebeane@amd.com DPRINTF(KvmIO, "KVM: Finished timing request\n"); 20111629Smichael.lebeane@amd.com 20211629Smichael.lebeane@amd.com delete pkt; 20311629Smichael.lebeane@amd.com activeMMIOReqs--; 20411629Smichael.lebeane@amd.com 20511629Smichael.lebeane@amd.com // We can switch back into KVM when all pending and in-flight MMIO 20611629Smichael.lebeane@amd.com // operations have completed. 20711629Smichael.lebeane@amd.com if (!(activeMMIOReqs || pendingMMIOPkts.size())) { 20811629Smichael.lebeane@amd.com DPRINTF(KvmIO, "KVM: Finished all outstanding timing requests\n"); 20911629Smichael.lebeane@amd.com cpu->finishMMIOPending(); 21011629Smichael.lebeane@amd.com } 21111629Smichael.lebeane@amd.com return true; 21211629Smichael.lebeane@amd.com} 21311629Smichael.lebeane@amd.com 21411629Smichael.lebeane@amd.comvoid 21511629Smichael.lebeane@amd.comBaseKvmCPU::KVMCpuPort::recvReqRetry() 21611629Smichael.lebeane@amd.com{ 21711629Smichael.lebeane@amd.com DPRINTF(KvmIO, "KVM: Retry for timing request\n"); 21811629Smichael.lebeane@amd.com 21911629Smichael.lebeane@amd.com assert(pendingMMIOPkts.size()); 22011629Smichael.lebeane@amd.com 22111629Smichael.lebeane@amd.com // Assuming that we can issue infinite requests this cycle is a bit 22211629Smichael.lebeane@amd.com // unrealistic, but it's not worth modeling something more complex in 22311629Smichael.lebeane@amd.com // KVM. 22411629Smichael.lebeane@amd.com while (pendingMMIOPkts.size() && sendTimingReq(pendingMMIOPkts.front())) { 22511629Smichael.lebeane@amd.com pendingMMIOPkts.pop(); 22611629Smichael.lebeane@amd.com activeMMIOReqs++; 22711629Smichael.lebeane@amd.com } 22811629Smichael.lebeane@amd.com} 22911629Smichael.lebeane@amd.com 23011629Smichael.lebeane@amd.comvoid 23111629Smichael.lebeane@amd.comBaseKvmCPU::finishMMIOPending() 23211629Smichael.lebeane@amd.com{ 23311629Smichael.lebeane@amd.com assert(_status = RunningMMIOPending); 23411629Smichael.lebeane@amd.com assert(!tickEvent.scheduled()); 23511629Smichael.lebeane@amd.com 23611629Smichael.lebeane@amd.com _status = RunningServiceCompletion; 23711629Smichael.lebeane@amd.com schedule(tickEvent, nextCycle()); 23811629Smichael.lebeane@amd.com} 23911629Smichael.lebeane@amd.com 24010073Sandreas@sandberg.pp.sevoid 24110073Sandreas@sandberg.pp.seBaseKvmCPU::startupThread() 24210073Sandreas@sandberg.pp.se{ 24310073Sandreas@sandberg.pp.se // Do thread-specific initialization. We need to setup signal 24410073Sandreas@sandberg.pp.se // delivery for counters and timers from within the thread that 24510073Sandreas@sandberg.pp.se // will execute the event queue to ensure that signals are 24610073Sandreas@sandberg.pp.se // delivered to the right threads. 24710073Sandreas@sandberg.pp.se const BaseKvmCPUParams * const p( 24810073Sandreas@sandberg.pp.se dynamic_cast<const BaseKvmCPUParams *>(params())); 24910073Sandreas@sandberg.pp.se 25010114Sandreas@sandberg.pp.se vcpuThread = pthread_self(); 25110114Sandreas@sandberg.pp.se 25210098Sandreas@sandberg.pp.se // Setup signal handlers. This has to be done after the vCPU is 25310098Sandreas@sandberg.pp.se // created since it manipulates the vCPU signal mask. 25410098Sandreas@sandberg.pp.se setupSignalHandler(); 25510098Sandreas@sandberg.pp.se 25610073Sandreas@sandberg.pp.se setupCounters(); 25710073Sandreas@sandberg.pp.se 25810073Sandreas@sandberg.pp.se if (p->usePerfOverflow) 25910073Sandreas@sandberg.pp.se runTimer.reset(new PerfKvmTimer(hwCycles, 26010114Sandreas@sandberg.pp.se KVM_KICK_SIGNAL, 26110073Sandreas@sandberg.pp.se p->hostFactor, 26210073Sandreas@sandberg.pp.se p->hostFreq)); 26310073Sandreas@sandberg.pp.se else 26410114Sandreas@sandberg.pp.se runTimer.reset(new PosixKvmTimer(KVM_KICK_SIGNAL, CLOCK_MONOTONIC, 26510073Sandreas@sandberg.pp.se p->hostFactor, 26610073Sandreas@sandberg.pp.se p->hostFreq)); 26710073Sandreas@sandberg.pp.se 2689651SAndreas.Sandberg@ARM.com} 2699651SAndreas.Sandberg@ARM.com 2709651SAndreas.Sandberg@ARM.comvoid 2719651SAndreas.Sandberg@ARM.comBaseKvmCPU::regStats() 2729651SAndreas.Sandberg@ARM.com{ 2739651SAndreas.Sandberg@ARM.com using namespace Stats; 2749651SAndreas.Sandberg@ARM.com 2759651SAndreas.Sandberg@ARM.com BaseCPU::regStats(); 2769651SAndreas.Sandberg@ARM.com 2779684Sandreas@sandberg.pp.se numInsts 2789684Sandreas@sandberg.pp.se .name(name() + ".committedInsts") 2799684Sandreas@sandberg.pp.se .desc("Number of instructions committed") 2809684Sandreas@sandberg.pp.se ; 2819684Sandreas@sandberg.pp.se 2829651SAndreas.Sandberg@ARM.com numVMExits 2839651SAndreas.Sandberg@ARM.com .name(name() + ".numVMExits") 2849651SAndreas.Sandberg@ARM.com .desc("total number of KVM exits") 2859651SAndreas.Sandberg@ARM.com ; 2869651SAndreas.Sandberg@ARM.com 2879755Sandreas@sandberg.pp.se numVMHalfEntries 2889755Sandreas@sandberg.pp.se .name(name() + ".numVMHalfEntries") 2899755Sandreas@sandberg.pp.se .desc("number of KVM entries to finalize pending operations") 2909755Sandreas@sandberg.pp.se ; 2919755Sandreas@sandberg.pp.se 2929755Sandreas@sandberg.pp.se numExitSignal 2939755Sandreas@sandberg.pp.se .name(name() + ".numExitSignal") 2949755Sandreas@sandberg.pp.se .desc("exits due to signal delivery") 2959755Sandreas@sandberg.pp.se ; 2969755Sandreas@sandberg.pp.se 2979651SAndreas.Sandberg@ARM.com numMMIO 2989651SAndreas.Sandberg@ARM.com .name(name() + ".numMMIO") 2999651SAndreas.Sandberg@ARM.com .desc("number of VM exits due to memory mapped IO") 3009651SAndreas.Sandberg@ARM.com ; 3019651SAndreas.Sandberg@ARM.com 3029651SAndreas.Sandberg@ARM.com numCoalescedMMIO 3039651SAndreas.Sandberg@ARM.com .name(name() + ".numCoalescedMMIO") 3049651SAndreas.Sandberg@ARM.com .desc("number of coalesced memory mapped IO requests") 3059651SAndreas.Sandberg@ARM.com ; 3069651SAndreas.Sandberg@ARM.com 3079651SAndreas.Sandberg@ARM.com numIO 3089651SAndreas.Sandberg@ARM.com .name(name() + ".numIO") 3099651SAndreas.Sandberg@ARM.com .desc("number of VM exits due to legacy IO") 3109651SAndreas.Sandberg@ARM.com ; 3119651SAndreas.Sandberg@ARM.com 3129651SAndreas.Sandberg@ARM.com numHalt 3139651SAndreas.Sandberg@ARM.com .name(name() + ".numHalt") 3149651SAndreas.Sandberg@ARM.com .desc("number of VM exits due to wait for interrupt instructions") 3159651SAndreas.Sandberg@ARM.com ; 3169651SAndreas.Sandberg@ARM.com 3179651SAndreas.Sandberg@ARM.com numInterrupts 3189651SAndreas.Sandberg@ARM.com .name(name() + ".numInterrupts") 3199651SAndreas.Sandberg@ARM.com .desc("number of interrupts delivered") 3209651SAndreas.Sandberg@ARM.com ; 3219651SAndreas.Sandberg@ARM.com 3229651SAndreas.Sandberg@ARM.com numHypercalls 3239651SAndreas.Sandberg@ARM.com .name(name() + ".numHypercalls") 3249651SAndreas.Sandberg@ARM.com .desc("number of hypercalls") 3259651SAndreas.Sandberg@ARM.com ; 3269651SAndreas.Sandberg@ARM.com} 3279651SAndreas.Sandberg@ARM.com 3289651SAndreas.Sandberg@ARM.comvoid 32910905Sandreas.sandberg@arm.comBaseKvmCPU::serializeThread(CheckpointOut &cp, ThreadID tid) const 3309651SAndreas.Sandberg@ARM.com{ 3319683Sandreas@sandberg.pp.se if (DTRACE(Checkpoint)) { 3329683Sandreas@sandberg.pp.se DPRINTF(Checkpoint, "KVM: Serializing thread %i:\n", tid); 3339683Sandreas@sandberg.pp.se dump(); 3349683Sandreas@sandberg.pp.se } 3359683Sandreas@sandberg.pp.se 3369651SAndreas.Sandberg@ARM.com assert(tid == 0); 3379651SAndreas.Sandberg@ARM.com assert(_status == Idle); 33810905Sandreas.sandberg@arm.com thread->serialize(cp); 3399651SAndreas.Sandberg@ARM.com} 3409651SAndreas.Sandberg@ARM.com 3419651SAndreas.Sandberg@ARM.comvoid 34210905Sandreas.sandberg@arm.comBaseKvmCPU::unserializeThread(CheckpointIn &cp, ThreadID tid) 3439651SAndreas.Sandberg@ARM.com{ 3449683Sandreas@sandberg.pp.se DPRINTF(Checkpoint, "KVM: Unserialize thread %i:\n", tid); 3459683Sandreas@sandberg.pp.se 3469651SAndreas.Sandberg@ARM.com assert(tid == 0); 3479651SAndreas.Sandberg@ARM.com assert(_status == Idle); 34810905Sandreas.sandberg@arm.com thread->unserialize(cp); 3499652SAndreas.Sandberg@ARM.com threadContextDirty = true; 3509651SAndreas.Sandberg@ARM.com} 3519651SAndreas.Sandberg@ARM.com 35210913Sandreas.sandberg@arm.comDrainState 35310913Sandreas.sandberg@arm.comBaseKvmCPU::drain() 3549651SAndreas.Sandberg@ARM.com{ 3559651SAndreas.Sandberg@ARM.com if (switchedOut()) 35610913Sandreas.sandberg@arm.com return DrainState::Drained; 3579651SAndreas.Sandberg@ARM.com 3589753Sandreas@sandberg.pp.se DPRINTF(Drain, "BaseKvmCPU::drain\n"); 35912154Sandreas.sandberg@arm.com 36012154Sandreas.sandberg@arm.com // The event queue won't be locked when calling drain since that's 36112154Sandreas.sandberg@arm.com // not done from an event. Lock the event queue here to make sure 36212154Sandreas.sandberg@arm.com // that scoped migrations continue to work if we need to 36312154Sandreas.sandberg@arm.com // synchronize the thread context. 36412154Sandreas.sandberg@arm.com std::lock_guard<EventQueue> lock(*this->eventQueue()); 36512154Sandreas.sandberg@arm.com 3669753Sandreas@sandberg.pp.se switch (_status) { 3679753Sandreas@sandberg.pp.se case Running: 3689753Sandreas@sandberg.pp.se // The base KVM code is normally ready when it is in the 3699753Sandreas@sandberg.pp.se // Running state, but the architecture specific code might be 3709753Sandreas@sandberg.pp.se // of a different opinion. This may happen when the CPU been 3719753Sandreas@sandberg.pp.se // notified of an event that hasn't been accepted by the vCPU 3729753Sandreas@sandberg.pp.se // yet. 37310913Sandreas.sandberg@arm.com if (!archIsDrained()) 37410913Sandreas.sandberg@arm.com return DrainState::Draining; 3759651SAndreas.Sandberg@ARM.com 3769753Sandreas@sandberg.pp.se // The state of the CPU is consistent, so we don't need to do 3779753Sandreas@sandberg.pp.se // anything special to drain it. We simply de-schedule the 3789753Sandreas@sandberg.pp.se // tick event and enter the Idle state to prevent nasty things 3799753Sandreas@sandberg.pp.se // like MMIOs from happening. 3809753Sandreas@sandberg.pp.se if (tickEvent.scheduled()) 3819753Sandreas@sandberg.pp.se deschedule(tickEvent); 3829753Sandreas@sandberg.pp.se _status = Idle; 3839651SAndreas.Sandberg@ARM.com 38412392Sjason@lowepower.com M5_FALLTHROUGH; 3859753Sandreas@sandberg.pp.se case Idle: 3869753Sandreas@sandberg.pp.se // Idle, no need to drain 3879753Sandreas@sandberg.pp.se assert(!tickEvent.scheduled()); 3889753Sandreas@sandberg.pp.se 3899753Sandreas@sandberg.pp.se // Sync the thread context here since we'll need it when we 3909753Sandreas@sandberg.pp.se // switch CPUs or checkpoint the CPU. 3919753Sandreas@sandberg.pp.se syncThreadContext(); 3929753Sandreas@sandberg.pp.se 39310913Sandreas.sandberg@arm.com return DrainState::Drained; 3949753Sandreas@sandberg.pp.se 3959753Sandreas@sandberg.pp.se case RunningServiceCompletion: 3969753Sandreas@sandberg.pp.se // The CPU has just requested a service that was handled in 3979753Sandreas@sandberg.pp.se // the RunningService state, but the results have still not 3989753Sandreas@sandberg.pp.se // been reported to the CPU. Now, we /could/ probably just 3999753Sandreas@sandberg.pp.se // update the register state ourselves instead of letting KVM 4009753Sandreas@sandberg.pp.se // handle it, but that would be tricky. Instead, we enter KVM 4019753Sandreas@sandberg.pp.se // and let it do its stuff. 4029753Sandreas@sandberg.pp.se DPRINTF(Drain, "KVM CPU is waiting for service completion, " 4039753Sandreas@sandberg.pp.se "requesting drain.\n"); 40410913Sandreas.sandberg@arm.com return DrainState::Draining; 4059753Sandreas@sandberg.pp.se 40611629Smichael.lebeane@amd.com case RunningMMIOPending: 40711629Smichael.lebeane@amd.com // We need to drain since there are in-flight timing accesses 40811629Smichael.lebeane@amd.com DPRINTF(Drain, "KVM CPU is waiting for timing accesses to complete, " 40911629Smichael.lebeane@amd.com "requesting drain.\n"); 41011629Smichael.lebeane@amd.com return DrainState::Draining; 41111629Smichael.lebeane@amd.com 4129753Sandreas@sandberg.pp.se case RunningService: 4139753Sandreas@sandberg.pp.se // We need to drain since the CPU is waiting for service (e.g., MMIOs) 4149753Sandreas@sandberg.pp.se DPRINTF(Drain, "KVM CPU is waiting for service, requesting drain.\n"); 41510913Sandreas.sandberg@arm.com return DrainState::Draining; 4169753Sandreas@sandberg.pp.se 4179753Sandreas@sandberg.pp.se default: 4189753Sandreas@sandberg.pp.se panic("KVM: Unhandled CPU state in drain()\n"); 41910913Sandreas.sandberg@arm.com return DrainState::Drained; 4209753Sandreas@sandberg.pp.se } 4219651SAndreas.Sandberg@ARM.com} 4229651SAndreas.Sandberg@ARM.com 4239651SAndreas.Sandberg@ARM.comvoid 4249651SAndreas.Sandberg@ARM.comBaseKvmCPU::drainResume() 4259651SAndreas.Sandberg@ARM.com{ 4269651SAndreas.Sandberg@ARM.com assert(!tickEvent.scheduled()); 4279651SAndreas.Sandberg@ARM.com 4289651SAndreas.Sandberg@ARM.com // We might have been switched out. In that case, we don't need to 4299651SAndreas.Sandberg@ARM.com // do anything. 4309651SAndreas.Sandberg@ARM.com if (switchedOut()) 4319651SAndreas.Sandberg@ARM.com return; 4329651SAndreas.Sandberg@ARM.com 4339651SAndreas.Sandberg@ARM.com DPRINTF(Kvm, "drainResume\n"); 4349651SAndreas.Sandberg@ARM.com verifyMemoryMode(); 4359651SAndreas.Sandberg@ARM.com 4369651SAndreas.Sandberg@ARM.com // The tick event is de-scheduled as a part of the draining 4379651SAndreas.Sandberg@ARM.com // process. Re-schedule it if the thread context is active. 4389651SAndreas.Sandberg@ARM.com if (tc->status() == ThreadContext::Active) { 4399651SAndreas.Sandberg@ARM.com schedule(tickEvent, nextCycle()); 4409651SAndreas.Sandberg@ARM.com _status = Running; 4419651SAndreas.Sandberg@ARM.com } else { 4429651SAndreas.Sandberg@ARM.com _status = Idle; 4439651SAndreas.Sandberg@ARM.com } 4449651SAndreas.Sandberg@ARM.com} 4459651SAndreas.Sandberg@ARM.com 4469651SAndreas.Sandberg@ARM.comvoid 44711363Sandreas@sandberg.pp.seBaseKvmCPU::notifyFork() 44811363Sandreas@sandberg.pp.se{ 44911363Sandreas@sandberg.pp.se // We should have drained prior to forking, which means that the 45011363Sandreas@sandberg.pp.se // tick event shouldn't be scheduled and the CPU is idle. 45111363Sandreas@sandberg.pp.se assert(!tickEvent.scheduled()); 45211363Sandreas@sandberg.pp.se assert(_status == Idle); 45311363Sandreas@sandberg.pp.se 45411363Sandreas@sandberg.pp.se if (vcpuFD != -1) { 45511363Sandreas@sandberg.pp.se if (close(vcpuFD) == -1) 45611363Sandreas@sandberg.pp.se warn("kvm CPU: notifyFork failed to close vcpuFD\n"); 45711363Sandreas@sandberg.pp.se 45811363Sandreas@sandberg.pp.se if (_kvmRun) 45911363Sandreas@sandberg.pp.se munmap(_kvmRun, vcpuMMapSize); 46011363Sandreas@sandberg.pp.se 46111363Sandreas@sandberg.pp.se vcpuFD = -1; 46211363Sandreas@sandberg.pp.se _kvmRun = NULL; 46311363Sandreas@sandberg.pp.se 46411363Sandreas@sandberg.pp.se hwInstructions.detach(); 46511363Sandreas@sandberg.pp.se hwCycles.detach(); 46611363Sandreas@sandberg.pp.se } 46711363Sandreas@sandberg.pp.se} 46811363Sandreas@sandberg.pp.se 46911363Sandreas@sandberg.pp.sevoid 4709651SAndreas.Sandberg@ARM.comBaseKvmCPU::switchOut() 4719651SAndreas.Sandberg@ARM.com{ 4729652SAndreas.Sandberg@ARM.com DPRINTF(Kvm, "switchOut\n"); 4739652SAndreas.Sandberg@ARM.com 4749651SAndreas.Sandberg@ARM.com BaseCPU::switchOut(); 4759651SAndreas.Sandberg@ARM.com 4769651SAndreas.Sandberg@ARM.com // We should have drained prior to executing a switchOut, which 4779651SAndreas.Sandberg@ARM.com // means that the tick event shouldn't be scheduled and the CPU is 4789651SAndreas.Sandberg@ARM.com // idle. 4799651SAndreas.Sandberg@ARM.com assert(!tickEvent.scheduled()); 4809651SAndreas.Sandberg@ARM.com assert(_status == Idle); 4819651SAndreas.Sandberg@ARM.com} 4829651SAndreas.Sandberg@ARM.com 4839651SAndreas.Sandberg@ARM.comvoid 4849651SAndreas.Sandberg@ARM.comBaseKvmCPU::takeOverFrom(BaseCPU *cpu) 4859651SAndreas.Sandberg@ARM.com{ 4869651SAndreas.Sandberg@ARM.com DPRINTF(Kvm, "takeOverFrom\n"); 4879651SAndreas.Sandberg@ARM.com 4889651SAndreas.Sandberg@ARM.com BaseCPU::takeOverFrom(cpu); 4899651SAndreas.Sandberg@ARM.com 4909651SAndreas.Sandberg@ARM.com // We should have drained prior to executing a switchOut, which 4919651SAndreas.Sandberg@ARM.com // means that the tick event shouldn't be scheduled and the CPU is 4929651SAndreas.Sandberg@ARM.com // idle. 4939651SAndreas.Sandberg@ARM.com assert(!tickEvent.scheduled()); 4949651SAndreas.Sandberg@ARM.com assert(_status == Idle); 4959651SAndreas.Sandberg@ARM.com assert(threadContexts.size() == 1); 4969651SAndreas.Sandberg@ARM.com 4979753Sandreas@sandberg.pp.se // Force an update of the KVM state here instead of flagging the 4989753Sandreas@sandberg.pp.se // TC as dirty. This is not ideal from a performance point of 4999753Sandreas@sandberg.pp.se // view, but it makes debugging easier as it allows meaningful KVM 5009753Sandreas@sandberg.pp.se // state to be dumped before and after a takeover. 5019753Sandreas@sandberg.pp.se updateKvmState(); 5029753Sandreas@sandberg.pp.se threadContextDirty = false; 5039651SAndreas.Sandberg@ARM.com} 5049651SAndreas.Sandberg@ARM.com 5059651SAndreas.Sandberg@ARM.comvoid 5069651SAndreas.Sandberg@ARM.comBaseKvmCPU::verifyMemoryMode() const 5079651SAndreas.Sandberg@ARM.com{ 50811629Smichael.lebeane@amd.com if (!(system->bypassCaches())) { 5099651SAndreas.Sandberg@ARM.com fatal("The KVM-based CPUs requires the memory system to be in the " 51011629Smichael.lebeane@amd.com "'noncaching' mode.\n"); 5119651SAndreas.Sandberg@ARM.com } 5129651SAndreas.Sandberg@ARM.com} 5139651SAndreas.Sandberg@ARM.com 5149651SAndreas.Sandberg@ARM.comvoid 51511151Smitch.hayenga@arm.comBaseKvmCPU::wakeup(ThreadID tid) 5169651SAndreas.Sandberg@ARM.com{ 5179651SAndreas.Sandberg@ARM.com DPRINTF(Kvm, "wakeup()\n"); 51810157Sandreas@sandberg.pp.se // This method might have been called from another 51910157Sandreas@sandberg.pp.se // context. Migrate to this SimObject's event queue when 52010157Sandreas@sandberg.pp.se // delivering the wakeup signal. 52110157Sandreas@sandberg.pp.se EventQueue::ScopedMigration migrate(eventQueue()); 52210157Sandreas@sandberg.pp.se 52310157Sandreas@sandberg.pp.se // Kick the vCPU to get it to come out of KVM. 52410157Sandreas@sandberg.pp.se kick(); 5259651SAndreas.Sandberg@ARM.com 5269651SAndreas.Sandberg@ARM.com if (thread->status() != ThreadContext::Suspended) 5279651SAndreas.Sandberg@ARM.com return; 5289651SAndreas.Sandberg@ARM.com 5299651SAndreas.Sandberg@ARM.com thread->activate(); 5309651SAndreas.Sandberg@ARM.com} 5319651SAndreas.Sandberg@ARM.com 5329651SAndreas.Sandberg@ARM.comvoid 53310407Smitch.hayenga@arm.comBaseKvmCPU::activateContext(ThreadID thread_num) 5349651SAndreas.Sandberg@ARM.com{ 53510407Smitch.hayenga@arm.com DPRINTF(Kvm, "ActivateContext %d\n", thread_num); 5369651SAndreas.Sandberg@ARM.com 5379651SAndreas.Sandberg@ARM.com assert(thread_num == 0); 5389651SAndreas.Sandberg@ARM.com assert(thread); 5399651SAndreas.Sandberg@ARM.com 5409651SAndreas.Sandberg@ARM.com assert(_status == Idle); 5419651SAndreas.Sandberg@ARM.com assert(!tickEvent.scheduled()); 5429651SAndreas.Sandberg@ARM.com 5439754Sandreas@sandberg.pp.se numCycles += ticksToCycles(thread->lastActivate - thread->lastSuspend); 5449651SAndreas.Sandberg@ARM.com 54510407Smitch.hayenga@arm.com schedule(tickEvent, clockEdge(Cycles(0))); 5469651SAndreas.Sandberg@ARM.com _status = Running; 5479651SAndreas.Sandberg@ARM.com} 5489651SAndreas.Sandberg@ARM.com 5499651SAndreas.Sandberg@ARM.com 5509651SAndreas.Sandberg@ARM.comvoid 5519651SAndreas.Sandberg@ARM.comBaseKvmCPU::suspendContext(ThreadID thread_num) 5529651SAndreas.Sandberg@ARM.com{ 5539651SAndreas.Sandberg@ARM.com DPRINTF(Kvm, "SuspendContext %d\n", thread_num); 5549651SAndreas.Sandberg@ARM.com 5559651SAndreas.Sandberg@ARM.com assert(thread_num == 0); 5569651SAndreas.Sandberg@ARM.com assert(thread); 5579651SAndreas.Sandberg@ARM.com 5589651SAndreas.Sandberg@ARM.com if (_status == Idle) 5599651SAndreas.Sandberg@ARM.com return; 5609651SAndreas.Sandberg@ARM.com 56110553Salexandru.dutu@amd.com assert(_status == Running || _status == RunningServiceCompletion); 5629651SAndreas.Sandberg@ARM.com 5639651SAndreas.Sandberg@ARM.com // The tick event may no be scheduled if the quest has requested 5649651SAndreas.Sandberg@ARM.com // the monitor to wait for interrupts. The normal CPU models can 5659651SAndreas.Sandberg@ARM.com // get their tick events descheduled by quiesce instructions, but 5669651SAndreas.Sandberg@ARM.com // that can't happen here. 5679651SAndreas.Sandberg@ARM.com if (tickEvent.scheduled()) 5689651SAndreas.Sandberg@ARM.com deschedule(tickEvent); 5699651SAndreas.Sandberg@ARM.com 5709651SAndreas.Sandberg@ARM.com _status = Idle; 5719651SAndreas.Sandberg@ARM.com} 5729651SAndreas.Sandberg@ARM.com 5739651SAndreas.Sandberg@ARM.comvoid 5749651SAndreas.Sandberg@ARM.comBaseKvmCPU::deallocateContext(ThreadID thread_num) 5759651SAndreas.Sandberg@ARM.com{ 5769651SAndreas.Sandberg@ARM.com // for now, these are equivalent 5779651SAndreas.Sandberg@ARM.com suspendContext(thread_num); 5789651SAndreas.Sandberg@ARM.com} 5799651SAndreas.Sandberg@ARM.com 5809651SAndreas.Sandberg@ARM.comvoid 5819651SAndreas.Sandberg@ARM.comBaseKvmCPU::haltContext(ThreadID thread_num) 5829651SAndreas.Sandberg@ARM.com{ 5839651SAndreas.Sandberg@ARM.com // for now, these are equivalent 5849651SAndreas.Sandberg@ARM.com suspendContext(thread_num); 58512284Sjose.marinho@arm.com updateCycleCounters(BaseCPU::CPU_STATE_SLEEP); 5869651SAndreas.Sandberg@ARM.com} 5879651SAndreas.Sandberg@ARM.com 5889652SAndreas.Sandberg@ARM.comThreadContext * 5899652SAndreas.Sandberg@ARM.comBaseKvmCPU::getContext(int tn) 5909652SAndreas.Sandberg@ARM.com{ 5919652SAndreas.Sandberg@ARM.com assert(tn == 0); 5929652SAndreas.Sandberg@ARM.com syncThreadContext(); 5939652SAndreas.Sandberg@ARM.com return tc; 5949652SAndreas.Sandberg@ARM.com} 5959652SAndreas.Sandberg@ARM.com 5969652SAndreas.Sandberg@ARM.com 5979651SAndreas.Sandberg@ARM.comCounter 5989651SAndreas.Sandberg@ARM.comBaseKvmCPU::totalInsts() const 5999651SAndreas.Sandberg@ARM.com{ 6009752Sandreas@sandberg.pp.se return ctrInsts; 6019651SAndreas.Sandberg@ARM.com} 6029651SAndreas.Sandberg@ARM.com 6039651SAndreas.Sandberg@ARM.comCounter 6049651SAndreas.Sandberg@ARM.comBaseKvmCPU::totalOps() const 6059651SAndreas.Sandberg@ARM.com{ 6069651SAndreas.Sandberg@ARM.com hack_once("Pretending totalOps is equivalent to totalInsts()\n"); 6079752Sandreas@sandberg.pp.se return ctrInsts; 6089651SAndreas.Sandberg@ARM.com} 6099651SAndreas.Sandberg@ARM.com 6109651SAndreas.Sandberg@ARM.comvoid 61110905Sandreas.sandberg@arm.comBaseKvmCPU::dump() const 6129651SAndreas.Sandberg@ARM.com{ 6139651SAndreas.Sandberg@ARM.com inform("State dumping not implemented."); 6149651SAndreas.Sandberg@ARM.com} 6159651SAndreas.Sandberg@ARM.com 6169651SAndreas.Sandberg@ARM.comvoid 6179651SAndreas.Sandberg@ARM.comBaseKvmCPU::tick() 6189651SAndreas.Sandberg@ARM.com{ 6199753Sandreas@sandberg.pp.se Tick delay(0); 62011629Smichael.lebeane@amd.com assert(_status != Idle && _status != RunningMMIOPending); 6219651SAndreas.Sandberg@ARM.com 6229651SAndreas.Sandberg@ARM.com switch (_status) { 6239753Sandreas@sandberg.pp.se case RunningService: 6249753Sandreas@sandberg.pp.se // handleKvmExit() will determine the next state of the CPU 6259753Sandreas@sandberg.pp.se delay = handleKvmExit(); 6269753Sandreas@sandberg.pp.se 6279753Sandreas@sandberg.pp.se if (tryDrain()) 6289753Sandreas@sandberg.pp.se _status = Idle; 6299651SAndreas.Sandberg@ARM.com break; 6309651SAndreas.Sandberg@ARM.com 6319753Sandreas@sandberg.pp.se case RunningServiceCompletion: 6329753Sandreas@sandberg.pp.se case Running: { 63310858Sandreas.sandberg@arm.com const uint64_t nextInstEvent( 63410858Sandreas.sandberg@arm.com !comInstEventQueue[0]->empty() ? 63510858Sandreas.sandberg@arm.com comInstEventQueue[0]->nextTick() : UINT64_MAX); 63610858Sandreas.sandberg@arm.com // Enter into KVM and complete pending IO instructions if we 63710858Sandreas.sandberg@arm.com // have an instruction event pending. 63810858Sandreas.sandberg@arm.com const Tick ticksToExecute( 63910858Sandreas.sandberg@arm.com nextInstEvent > ctrInsts ? 64010858Sandreas.sandberg@arm.com curEventQueue()->nextTick() - curTick() : 0); 6419753Sandreas@sandberg.pp.se 64211399Sandreas.sandberg@arm.com if (alwaysSyncTC) 64311399Sandreas.sandberg@arm.com threadContextDirty = true; 64411399Sandreas.sandberg@arm.com 6459753Sandreas@sandberg.pp.se // We might need to update the KVM state. 6469753Sandreas@sandberg.pp.se syncKvmState(); 6479753Sandreas@sandberg.pp.se 6489892Sandreas@sandberg.pp.se // Setup any pending instruction count breakpoints using 64910858Sandreas.sandberg@arm.com // PerfEvent if we are going to execute more than just an IO 65010858Sandreas.sandberg@arm.com // completion. 65110858Sandreas.sandberg@arm.com if (ticksToExecute > 0) 65210858Sandreas.sandberg@arm.com setupInstStop(); 6539892Sandreas@sandberg.pp.se 6549753Sandreas@sandberg.pp.se DPRINTF(KvmRun, "Entering KVM...\n"); 65510913Sandreas.sandberg@arm.com if (drainState() == DrainState::Draining) { 6569753Sandreas@sandberg.pp.se // Force an immediate exit from KVM after completing 6579753Sandreas@sandberg.pp.se // pending operations. The architecture-specific code 6589753Sandreas@sandberg.pp.se // takes care to run until it is in a state where it can 6599753Sandreas@sandberg.pp.se // safely be drained. 6609753Sandreas@sandberg.pp.se delay = kvmRunDrain(); 6619753Sandreas@sandberg.pp.se } else { 6629753Sandreas@sandberg.pp.se delay = kvmRun(ticksToExecute); 6639753Sandreas@sandberg.pp.se } 6649753Sandreas@sandberg.pp.se 66510112Sandreas@sandberg.pp.se // The CPU might have been suspended before entering into 66610112Sandreas@sandberg.pp.se // KVM. Assume that the CPU was suspended /before/ entering 66710112Sandreas@sandberg.pp.se // into KVM and skip the exit handling. 66810112Sandreas@sandberg.pp.se if (_status == Idle) 66910112Sandreas@sandberg.pp.se break; 67010112Sandreas@sandberg.pp.se 6719753Sandreas@sandberg.pp.se // Entering into KVM implies that we'll have to reload the thread 6729753Sandreas@sandberg.pp.se // context from KVM if we want to access it. Flag the KVM state as 6739753Sandreas@sandberg.pp.se // dirty with respect to the cached thread context. 6749753Sandreas@sandberg.pp.se kvmStateDirty = true; 6759753Sandreas@sandberg.pp.se 67611399Sandreas.sandberg@arm.com if (alwaysSyncTC) 67711399Sandreas.sandberg@arm.com syncThreadContext(); 67811399Sandreas.sandberg@arm.com 6799753Sandreas@sandberg.pp.se // Enter into the RunningService state unless the 6809753Sandreas@sandberg.pp.se // simulation was stopped by a timer. 6819755Sandreas@sandberg.pp.se if (_kvmRun->exit_reason != KVM_EXIT_INTR) { 6829753Sandreas@sandberg.pp.se _status = RunningService; 6839755Sandreas@sandberg.pp.se } else { 6849755Sandreas@sandberg.pp.se ++numExitSignal; 6859753Sandreas@sandberg.pp.se _status = Running; 6869755Sandreas@sandberg.pp.se } 6879753Sandreas@sandberg.pp.se 6889904Sandreas@sandberg.pp.se // Service any pending instruction events. The vCPU should 6899904Sandreas@sandberg.pp.se // have exited in time for the event using the instruction 6909904Sandreas@sandberg.pp.se // counter configured by setupInstStop(). 6919904Sandreas@sandberg.pp.se comInstEventQueue[0]->serviceEvents(ctrInsts); 6929904Sandreas@sandberg.pp.se system->instEventQueue.serviceEvents(system->totalNumInsts); 6939904Sandreas@sandberg.pp.se 6949753Sandreas@sandberg.pp.se if (tryDrain()) 6959753Sandreas@sandberg.pp.se _status = Idle; 6969753Sandreas@sandberg.pp.se } break; 6979753Sandreas@sandberg.pp.se 6989651SAndreas.Sandberg@ARM.com default: 6999753Sandreas@sandberg.pp.se panic("BaseKvmCPU entered tick() in an illegal state (%i)\n", 7009753Sandreas@sandberg.pp.se _status); 7019651SAndreas.Sandberg@ARM.com } 7029753Sandreas@sandberg.pp.se 7039753Sandreas@sandberg.pp.se // Schedule a new tick if we are still running 70411629Smichael.lebeane@amd.com if (_status != Idle && _status != RunningMMIOPending) 7059753Sandreas@sandberg.pp.se schedule(tickEvent, clockEdge(ticksToCycles(delay))); 7069753Sandreas@sandberg.pp.se} 7079753Sandreas@sandberg.pp.se 7089753Sandreas@sandberg.pp.seTick 7099753Sandreas@sandberg.pp.seBaseKvmCPU::kvmRunDrain() 7109753Sandreas@sandberg.pp.se{ 7119753Sandreas@sandberg.pp.se // By default, the only thing we need to drain is a pending IO 7129753Sandreas@sandberg.pp.se // operation which assumes that we are in the 71311629Smichael.lebeane@amd.com // RunningServiceCompletion or RunningMMIOPending state. 71411629Smichael.lebeane@amd.com assert(_status == RunningServiceCompletion || 71511629Smichael.lebeane@amd.com _status == RunningMMIOPending); 7169753Sandreas@sandberg.pp.se 7179753Sandreas@sandberg.pp.se // Deliver the data from the pending IO operation and immediately 7189753Sandreas@sandberg.pp.se // exit. 7199753Sandreas@sandberg.pp.se return kvmRun(0); 7209651SAndreas.Sandberg@ARM.com} 7219651SAndreas.Sandberg@ARM.com 7229735Sandreas@sandberg.pp.seuint64_t 7239735Sandreas@sandberg.pp.seBaseKvmCPU::getHostCycles() const 7249735Sandreas@sandberg.pp.se{ 7259735Sandreas@sandberg.pp.se return hwCycles.read(); 7269735Sandreas@sandberg.pp.se} 7279735Sandreas@sandberg.pp.se 7289651SAndreas.Sandberg@ARM.comTick 7299651SAndreas.Sandberg@ARM.comBaseKvmCPU::kvmRun(Tick ticks) 7309651SAndreas.Sandberg@ARM.com{ 7319753Sandreas@sandberg.pp.se Tick ticksExecuted; 73211363Sandreas@sandberg.pp.se fatal_if(vcpuFD == -1, 73311363Sandreas@sandberg.pp.se "Trying to run a KVM CPU in a forked child process. " 73411363Sandreas@sandberg.pp.se "This is not supported.\n"); 7359651SAndreas.Sandberg@ARM.com DPRINTF(KvmRun, "KVM: Executing for %i ticks\n", ticks); 7369655SAndreas.Sandberg@ARM.com 7379753Sandreas@sandberg.pp.se if (ticks == 0) { 7389753Sandreas@sandberg.pp.se // Settings ticks == 0 is a special case which causes an entry 7399753Sandreas@sandberg.pp.se // into KVM that finishes pending operations (e.g., IO) and 7409753Sandreas@sandberg.pp.se // then immediately exits. 7419753Sandreas@sandberg.pp.se DPRINTF(KvmRun, "KVM: Delivering IO without full guest entry\n"); 7429735Sandreas@sandberg.pp.se 7439755Sandreas@sandberg.pp.se ++numVMHalfEntries; 7449755Sandreas@sandberg.pp.se 74510114Sandreas@sandberg.pp.se // Send a KVM_KICK_SIGNAL to the vCPU thread (i.e., this 74610114Sandreas@sandberg.pp.se // thread). The KVM control signal is masked while executing 74710114Sandreas@sandberg.pp.se // in gem5 and gets unmasked temporarily as when entering 7489753Sandreas@sandberg.pp.se // KVM. See setSignalMask() and setupSignalHandler(). 74910114Sandreas@sandberg.pp.se kick(); 7509655SAndreas.Sandberg@ARM.com 75110114Sandreas@sandberg.pp.se // Start the vCPU. KVM will check for signals after completing 75210114Sandreas@sandberg.pp.se // pending operations (IO). Since the KVM_KICK_SIGNAL is 75310114Sandreas@sandberg.pp.se // pending, this forces an immediate exit to gem5 again. We 7549753Sandreas@sandberg.pp.se // don't bother to setup timers since this shouldn't actually 75510114Sandreas@sandberg.pp.se // execute any code (other than completing half-executed IO 75610114Sandreas@sandberg.pp.se // instructions) in the guest. 7579753Sandreas@sandberg.pp.se ioctlRun(); 7589753Sandreas@sandberg.pp.se 7599753Sandreas@sandberg.pp.se // We always execute at least one cycle to prevent the 7609753Sandreas@sandberg.pp.se // BaseKvmCPU::tick() to be rescheduled on the same tick 7619753Sandreas@sandberg.pp.se // twice. 7629753Sandreas@sandberg.pp.se ticksExecuted = clockPeriod(); 7639753Sandreas@sandberg.pp.se } else { 76410157Sandreas@sandberg.pp.se // This method is executed as a result of a tick event. That 76510157Sandreas@sandberg.pp.se // means that the event queue will be locked when entering the 76610157Sandreas@sandberg.pp.se // method. We temporarily unlock the event queue to allow 76710157Sandreas@sandberg.pp.se // other threads to steal control of this thread to inject 76810157Sandreas@sandberg.pp.se // interrupts. They will typically lock the queue and then 76910157Sandreas@sandberg.pp.se // force an exit from KVM by kicking the vCPU. 77010157Sandreas@sandberg.pp.se EventQueue::ScopedRelease release(curEventQueue()); 77110157Sandreas@sandberg.pp.se 7729753Sandreas@sandberg.pp.se if (ticks < runTimer->resolution()) { 7739753Sandreas@sandberg.pp.se DPRINTF(KvmRun, "KVM: Adjusting tick count (%i -> %i)\n", 7749753Sandreas@sandberg.pp.se ticks, runTimer->resolution()); 7759753Sandreas@sandberg.pp.se ticks = runTimer->resolution(); 7769753Sandreas@sandberg.pp.se } 7779753Sandreas@sandberg.pp.se 7789753Sandreas@sandberg.pp.se // Get hardware statistics after synchronizing contexts. The KVM 7799753Sandreas@sandberg.pp.se // state update might affect guest cycle counters. 7809753Sandreas@sandberg.pp.se uint64_t baseCycles(getHostCycles()); 7819753Sandreas@sandberg.pp.se uint64_t baseInstrs(hwInstructions.read()); 7829753Sandreas@sandberg.pp.se 7839753Sandreas@sandberg.pp.se // Arm the run timer and start the cycle timer if it isn't 7849753Sandreas@sandberg.pp.se // controlled by the overflow timer. Starting/stopping the cycle 7859753Sandreas@sandberg.pp.se // timer automatically starts the other perf timers as they are in 7869753Sandreas@sandberg.pp.se // the same counter group. 7879753Sandreas@sandberg.pp.se runTimer->arm(ticks); 7889753Sandreas@sandberg.pp.se if (!perfControlledByTimer) 7899753Sandreas@sandberg.pp.se hwCycles.start(); 7909753Sandreas@sandberg.pp.se 7919753Sandreas@sandberg.pp.se ioctlRun(); 7929753Sandreas@sandberg.pp.se 7939753Sandreas@sandberg.pp.se runTimer->disarm(); 7949753Sandreas@sandberg.pp.se if (!perfControlledByTimer) 7959753Sandreas@sandberg.pp.se hwCycles.stop(); 7969753Sandreas@sandberg.pp.se 79710114Sandreas@sandberg.pp.se // The control signal may have been delivered after we exited 7989753Sandreas@sandberg.pp.se // from KVM. It will be pending in that case since it is 7999753Sandreas@sandberg.pp.se // masked when we aren't executing in KVM. Discard it to make 8009753Sandreas@sandberg.pp.se // sure we don't deliver it immediately next time we try to 8019753Sandreas@sandberg.pp.se // enter into KVM. 80210114Sandreas@sandberg.pp.se discardPendingSignal(KVM_KICK_SIGNAL); 8039753Sandreas@sandberg.pp.se 8049753Sandreas@sandberg.pp.se const uint64_t hostCyclesExecuted(getHostCycles() - baseCycles); 8059753Sandreas@sandberg.pp.se const uint64_t simCyclesExecuted(hostCyclesExecuted * hostFactor); 8069753Sandreas@sandberg.pp.se const uint64_t instsExecuted(hwInstructions.read() - baseInstrs); 8079753Sandreas@sandberg.pp.se ticksExecuted = runTimer->ticksFromHostCycles(hostCyclesExecuted); 8089753Sandreas@sandberg.pp.se 8099753Sandreas@sandberg.pp.se /* Update statistics */ 8109753Sandreas@sandberg.pp.se numCycles += simCyclesExecuted;; 8119753Sandreas@sandberg.pp.se numInsts += instsExecuted; 8129753Sandreas@sandberg.pp.se ctrInsts += instsExecuted; 8139753Sandreas@sandberg.pp.se system->totalNumInsts += instsExecuted; 8149753Sandreas@sandberg.pp.se 8159753Sandreas@sandberg.pp.se DPRINTF(KvmRun, 8169753Sandreas@sandberg.pp.se "KVM: Executed %i instructions in %i cycles " 8179753Sandreas@sandberg.pp.se "(%i ticks, sim cycles: %i).\n", 8189753Sandreas@sandberg.pp.se instsExecuted, hostCyclesExecuted, ticksExecuted, simCyclesExecuted); 8199651SAndreas.Sandberg@ARM.com } 8209655SAndreas.Sandberg@ARM.com 8219651SAndreas.Sandberg@ARM.com ++numVMExits; 8229651SAndreas.Sandberg@ARM.com 8239651SAndreas.Sandberg@ARM.com return ticksExecuted + flushCoalescedMMIO(); 8249651SAndreas.Sandberg@ARM.com} 8259651SAndreas.Sandberg@ARM.com 8269651SAndreas.Sandberg@ARM.comvoid 8279651SAndreas.Sandberg@ARM.comBaseKvmCPU::kvmNonMaskableInterrupt() 8289651SAndreas.Sandberg@ARM.com{ 8299651SAndreas.Sandberg@ARM.com ++numInterrupts; 8309651SAndreas.Sandberg@ARM.com if (ioctl(KVM_NMI) == -1) 8319651SAndreas.Sandberg@ARM.com panic("KVM: Failed to deliver NMI to virtual CPU\n"); 8329651SAndreas.Sandberg@ARM.com} 8339651SAndreas.Sandberg@ARM.com 8349651SAndreas.Sandberg@ARM.comvoid 8359651SAndreas.Sandberg@ARM.comBaseKvmCPU::kvmInterrupt(const struct kvm_interrupt &interrupt) 8369651SAndreas.Sandberg@ARM.com{ 8379651SAndreas.Sandberg@ARM.com ++numInterrupts; 8389651SAndreas.Sandberg@ARM.com if (ioctl(KVM_INTERRUPT, (void *)&interrupt) == -1) 8399651SAndreas.Sandberg@ARM.com panic("KVM: Failed to deliver interrupt to virtual CPU\n"); 8409651SAndreas.Sandberg@ARM.com} 8419651SAndreas.Sandberg@ARM.com 8429651SAndreas.Sandberg@ARM.comvoid 8439651SAndreas.Sandberg@ARM.comBaseKvmCPU::getRegisters(struct kvm_regs ®s) const 8449651SAndreas.Sandberg@ARM.com{ 8459651SAndreas.Sandberg@ARM.com if (ioctl(KVM_GET_REGS, ®s) == -1) 8469651SAndreas.Sandberg@ARM.com panic("KVM: Failed to get guest registers\n"); 8479651SAndreas.Sandberg@ARM.com} 8489651SAndreas.Sandberg@ARM.com 8499651SAndreas.Sandberg@ARM.comvoid 8509651SAndreas.Sandberg@ARM.comBaseKvmCPU::setRegisters(const struct kvm_regs ®s) 8519651SAndreas.Sandberg@ARM.com{ 8529651SAndreas.Sandberg@ARM.com if (ioctl(KVM_SET_REGS, (void *)®s) == -1) 8539651SAndreas.Sandberg@ARM.com panic("KVM: Failed to set guest registers\n"); 8549651SAndreas.Sandberg@ARM.com} 8559651SAndreas.Sandberg@ARM.com 8569651SAndreas.Sandberg@ARM.comvoid 8579651SAndreas.Sandberg@ARM.comBaseKvmCPU::getSpecialRegisters(struct kvm_sregs ®s) const 8589651SAndreas.Sandberg@ARM.com{ 8599651SAndreas.Sandberg@ARM.com if (ioctl(KVM_GET_SREGS, ®s) == -1) 8609651SAndreas.Sandberg@ARM.com panic("KVM: Failed to get guest special registers\n"); 8619651SAndreas.Sandberg@ARM.com} 8629651SAndreas.Sandberg@ARM.com 8639651SAndreas.Sandberg@ARM.comvoid 8649651SAndreas.Sandberg@ARM.comBaseKvmCPU::setSpecialRegisters(const struct kvm_sregs ®s) 8659651SAndreas.Sandberg@ARM.com{ 8669651SAndreas.Sandberg@ARM.com if (ioctl(KVM_SET_SREGS, (void *)®s) == -1) 8679651SAndreas.Sandberg@ARM.com panic("KVM: Failed to set guest special registers\n"); 8689651SAndreas.Sandberg@ARM.com} 8699651SAndreas.Sandberg@ARM.com 8709651SAndreas.Sandberg@ARM.comvoid 8719651SAndreas.Sandberg@ARM.comBaseKvmCPU::getFPUState(struct kvm_fpu &state) const 8729651SAndreas.Sandberg@ARM.com{ 8739651SAndreas.Sandberg@ARM.com if (ioctl(KVM_GET_FPU, &state) == -1) 8749651SAndreas.Sandberg@ARM.com panic("KVM: Failed to get guest FPU state\n"); 8759651SAndreas.Sandberg@ARM.com} 8769651SAndreas.Sandberg@ARM.com 8779651SAndreas.Sandberg@ARM.comvoid 8789651SAndreas.Sandberg@ARM.comBaseKvmCPU::setFPUState(const struct kvm_fpu &state) 8799651SAndreas.Sandberg@ARM.com{ 8809651SAndreas.Sandberg@ARM.com if (ioctl(KVM_SET_FPU, (void *)&state) == -1) 8819651SAndreas.Sandberg@ARM.com panic("KVM: Failed to set guest FPU state\n"); 8829651SAndreas.Sandberg@ARM.com} 8839651SAndreas.Sandberg@ARM.com 8849651SAndreas.Sandberg@ARM.com 8859651SAndreas.Sandberg@ARM.comvoid 8869651SAndreas.Sandberg@ARM.comBaseKvmCPU::setOneReg(uint64_t id, const void *addr) 8879651SAndreas.Sandberg@ARM.com{ 8889651SAndreas.Sandberg@ARM.com#ifdef KVM_SET_ONE_REG 8899651SAndreas.Sandberg@ARM.com struct kvm_one_reg reg; 8909651SAndreas.Sandberg@ARM.com reg.id = id; 8919651SAndreas.Sandberg@ARM.com reg.addr = (uint64_t)addr; 8929651SAndreas.Sandberg@ARM.com 8939651SAndreas.Sandberg@ARM.com if (ioctl(KVM_SET_ONE_REG, ®) == -1) { 8949651SAndreas.Sandberg@ARM.com panic("KVM: Failed to set register (0x%x) value (errno: %i)\n", 8959651SAndreas.Sandberg@ARM.com id, errno); 8969651SAndreas.Sandberg@ARM.com } 8979651SAndreas.Sandberg@ARM.com#else 8989651SAndreas.Sandberg@ARM.com panic("KVM_SET_ONE_REG is unsupported on this platform.\n"); 8999651SAndreas.Sandberg@ARM.com#endif 9009651SAndreas.Sandberg@ARM.com} 9019651SAndreas.Sandberg@ARM.com 9029651SAndreas.Sandberg@ARM.comvoid 9039651SAndreas.Sandberg@ARM.comBaseKvmCPU::getOneReg(uint64_t id, void *addr) const 9049651SAndreas.Sandberg@ARM.com{ 9059651SAndreas.Sandberg@ARM.com#ifdef KVM_GET_ONE_REG 9069651SAndreas.Sandberg@ARM.com struct kvm_one_reg reg; 9079651SAndreas.Sandberg@ARM.com reg.id = id; 9089651SAndreas.Sandberg@ARM.com reg.addr = (uint64_t)addr; 9099651SAndreas.Sandberg@ARM.com 9109651SAndreas.Sandberg@ARM.com if (ioctl(KVM_GET_ONE_REG, ®) == -1) { 9119651SAndreas.Sandberg@ARM.com panic("KVM: Failed to get register (0x%x) value (errno: %i)\n", 9129651SAndreas.Sandberg@ARM.com id, errno); 9139651SAndreas.Sandberg@ARM.com } 9149651SAndreas.Sandberg@ARM.com#else 9159651SAndreas.Sandberg@ARM.com panic("KVM_GET_ONE_REG is unsupported on this platform.\n"); 9169651SAndreas.Sandberg@ARM.com#endif 9179651SAndreas.Sandberg@ARM.com} 9189651SAndreas.Sandberg@ARM.com 9199651SAndreas.Sandberg@ARM.comstd::string 9209651SAndreas.Sandberg@ARM.comBaseKvmCPU::getAndFormatOneReg(uint64_t id) const 9219651SAndreas.Sandberg@ARM.com{ 9229651SAndreas.Sandberg@ARM.com#ifdef KVM_GET_ONE_REG 9239651SAndreas.Sandberg@ARM.com std::ostringstream ss; 9249651SAndreas.Sandberg@ARM.com 9259651SAndreas.Sandberg@ARM.com ss.setf(std::ios::hex, std::ios::basefield); 9269651SAndreas.Sandberg@ARM.com ss.setf(std::ios::showbase); 9279651SAndreas.Sandberg@ARM.com#define HANDLE_INTTYPE(len) \ 9289651SAndreas.Sandberg@ARM.com case KVM_REG_SIZE_U ## len: { \ 9299651SAndreas.Sandberg@ARM.com uint ## len ## _t value; \ 9309651SAndreas.Sandberg@ARM.com getOneReg(id, &value); \ 9319651SAndreas.Sandberg@ARM.com ss << value; \ 9329651SAndreas.Sandberg@ARM.com } break 9339651SAndreas.Sandberg@ARM.com 93410843Sandreas.sandberg@arm.com#define HANDLE_ARRAY(len) \ 93510843Sandreas.sandberg@arm.com case KVM_REG_SIZE_U ## len: { \ 93610843Sandreas.sandberg@arm.com uint8_t value[len / 8]; \ 93710843Sandreas.sandberg@arm.com getOneReg(id, value); \ 93810843Sandreas.sandberg@arm.com ccprintf(ss, "[0x%x", value[0]); \ 93910843Sandreas.sandberg@arm.com for (int i = 1; i < len / 8; ++i) \ 94010843Sandreas.sandberg@arm.com ccprintf(ss, ", 0x%x", value[i]); \ 94110843Sandreas.sandberg@arm.com ccprintf(ss, "]"); \ 9429651SAndreas.Sandberg@ARM.com } break 9439651SAndreas.Sandberg@ARM.com 9449651SAndreas.Sandberg@ARM.com switch (id & KVM_REG_SIZE_MASK) { 9459651SAndreas.Sandberg@ARM.com HANDLE_INTTYPE(8); 9469651SAndreas.Sandberg@ARM.com HANDLE_INTTYPE(16); 9479651SAndreas.Sandberg@ARM.com HANDLE_INTTYPE(32); 9489651SAndreas.Sandberg@ARM.com HANDLE_INTTYPE(64); 9499651SAndreas.Sandberg@ARM.com HANDLE_ARRAY(128); 9509651SAndreas.Sandberg@ARM.com HANDLE_ARRAY(256); 9519651SAndreas.Sandberg@ARM.com HANDLE_ARRAY(512); 9529651SAndreas.Sandberg@ARM.com HANDLE_ARRAY(1024); 9539651SAndreas.Sandberg@ARM.com default: 9549651SAndreas.Sandberg@ARM.com ss << "??"; 9559651SAndreas.Sandberg@ARM.com } 9569651SAndreas.Sandberg@ARM.com 9579651SAndreas.Sandberg@ARM.com#undef HANDLE_INTTYPE 9589651SAndreas.Sandberg@ARM.com#undef HANDLE_ARRAY 9599651SAndreas.Sandberg@ARM.com 9609651SAndreas.Sandberg@ARM.com return ss.str(); 9619651SAndreas.Sandberg@ARM.com#else 9629651SAndreas.Sandberg@ARM.com panic("KVM_GET_ONE_REG is unsupported on this platform.\n"); 9639651SAndreas.Sandberg@ARM.com#endif 9649651SAndreas.Sandberg@ARM.com} 9659651SAndreas.Sandberg@ARM.com 9669652SAndreas.Sandberg@ARM.comvoid 9679652SAndreas.Sandberg@ARM.comBaseKvmCPU::syncThreadContext() 9689652SAndreas.Sandberg@ARM.com{ 9699652SAndreas.Sandberg@ARM.com if (!kvmStateDirty) 9709652SAndreas.Sandberg@ARM.com return; 9719652SAndreas.Sandberg@ARM.com 9729652SAndreas.Sandberg@ARM.com assert(!threadContextDirty); 9739652SAndreas.Sandberg@ARM.com 9749652SAndreas.Sandberg@ARM.com updateThreadContext(); 9759652SAndreas.Sandberg@ARM.com kvmStateDirty = false; 9769652SAndreas.Sandberg@ARM.com} 9779652SAndreas.Sandberg@ARM.com 9789652SAndreas.Sandberg@ARM.comvoid 9799652SAndreas.Sandberg@ARM.comBaseKvmCPU::syncKvmState() 9809652SAndreas.Sandberg@ARM.com{ 9819652SAndreas.Sandberg@ARM.com if (!threadContextDirty) 9829652SAndreas.Sandberg@ARM.com return; 9839652SAndreas.Sandberg@ARM.com 9849652SAndreas.Sandberg@ARM.com assert(!kvmStateDirty); 9859652SAndreas.Sandberg@ARM.com 9869652SAndreas.Sandberg@ARM.com updateKvmState(); 9879652SAndreas.Sandberg@ARM.com threadContextDirty = false; 9889652SAndreas.Sandberg@ARM.com} 9899652SAndreas.Sandberg@ARM.com 9909651SAndreas.Sandberg@ARM.comTick 9919651SAndreas.Sandberg@ARM.comBaseKvmCPU::handleKvmExit() 9929651SAndreas.Sandberg@ARM.com{ 9939651SAndreas.Sandberg@ARM.com DPRINTF(KvmRun, "handleKvmExit (exit_reason: %i)\n", _kvmRun->exit_reason); 9949753Sandreas@sandberg.pp.se assert(_status == RunningService); 9959651SAndreas.Sandberg@ARM.com 9969753Sandreas@sandberg.pp.se // Switch into the running state by default. Individual handlers 9979753Sandreas@sandberg.pp.se // can override this. 9989753Sandreas@sandberg.pp.se _status = Running; 9999651SAndreas.Sandberg@ARM.com switch (_kvmRun->exit_reason) { 10009651SAndreas.Sandberg@ARM.com case KVM_EXIT_UNKNOWN: 10019651SAndreas.Sandberg@ARM.com return handleKvmExitUnknown(); 10029651SAndreas.Sandberg@ARM.com 10039651SAndreas.Sandberg@ARM.com case KVM_EXIT_EXCEPTION: 10049651SAndreas.Sandberg@ARM.com return handleKvmExitException(); 10059651SAndreas.Sandberg@ARM.com 10069651SAndreas.Sandberg@ARM.com case KVM_EXIT_IO: 100711629Smichael.lebeane@amd.com { 10089651SAndreas.Sandberg@ARM.com ++numIO; 100911629Smichael.lebeane@amd.com Tick ticks = handleKvmExitIO(); 101011629Smichael.lebeane@amd.com _status = dataPort.nextIOState(); 101111629Smichael.lebeane@amd.com return ticks; 101211629Smichael.lebeane@amd.com } 10139651SAndreas.Sandberg@ARM.com 10149651SAndreas.Sandberg@ARM.com case KVM_EXIT_HYPERCALL: 10159651SAndreas.Sandberg@ARM.com ++numHypercalls; 10169651SAndreas.Sandberg@ARM.com return handleKvmExitHypercall(); 10179651SAndreas.Sandberg@ARM.com 10189651SAndreas.Sandberg@ARM.com case KVM_EXIT_HLT: 10199651SAndreas.Sandberg@ARM.com /* The guest has halted and is waiting for interrupts */ 10209651SAndreas.Sandberg@ARM.com DPRINTF(Kvm, "handleKvmExitHalt\n"); 10219651SAndreas.Sandberg@ARM.com ++numHalt; 10229651SAndreas.Sandberg@ARM.com 10239651SAndreas.Sandberg@ARM.com // Suspend the thread until the next interrupt arrives 10249651SAndreas.Sandberg@ARM.com thread->suspend(); 10259651SAndreas.Sandberg@ARM.com 10269651SAndreas.Sandberg@ARM.com // This is actually ignored since the thread is suspended. 10279651SAndreas.Sandberg@ARM.com return 0; 10289651SAndreas.Sandberg@ARM.com 10299651SAndreas.Sandberg@ARM.com case KVM_EXIT_MMIO: 103011629Smichael.lebeane@amd.com { 10319651SAndreas.Sandberg@ARM.com /* Service memory mapped IO requests */ 10329651SAndreas.Sandberg@ARM.com DPRINTF(KvmIO, "KVM: Handling MMIO (w: %u, addr: 0x%x, len: %u)\n", 10339651SAndreas.Sandberg@ARM.com _kvmRun->mmio.is_write, 10349651SAndreas.Sandberg@ARM.com _kvmRun->mmio.phys_addr, _kvmRun->mmio.len); 10359651SAndreas.Sandberg@ARM.com 10369651SAndreas.Sandberg@ARM.com ++numMMIO; 103711629Smichael.lebeane@amd.com Tick ticks = doMMIOAccess(_kvmRun->mmio.phys_addr, _kvmRun->mmio.data, 103811629Smichael.lebeane@amd.com _kvmRun->mmio.len, _kvmRun->mmio.is_write); 103911629Smichael.lebeane@amd.com // doMMIOAccess could have triggered a suspend, in which case we don't 104011629Smichael.lebeane@amd.com // want to overwrite the _status. 104111629Smichael.lebeane@amd.com if (_status != Idle) 104211629Smichael.lebeane@amd.com _status = dataPort.nextIOState(); 104311629Smichael.lebeane@amd.com return ticks; 104411629Smichael.lebeane@amd.com } 10459651SAndreas.Sandberg@ARM.com 10469651SAndreas.Sandberg@ARM.com case KVM_EXIT_IRQ_WINDOW_OPEN: 10479651SAndreas.Sandberg@ARM.com return handleKvmExitIRQWindowOpen(); 10489651SAndreas.Sandberg@ARM.com 10499651SAndreas.Sandberg@ARM.com case KVM_EXIT_FAIL_ENTRY: 10509651SAndreas.Sandberg@ARM.com return handleKvmExitFailEntry(); 10519651SAndreas.Sandberg@ARM.com 10529651SAndreas.Sandberg@ARM.com case KVM_EXIT_INTR: 10539651SAndreas.Sandberg@ARM.com /* KVM was interrupted by a signal, restart it in the next 10549651SAndreas.Sandberg@ARM.com * tick. */ 10559651SAndreas.Sandberg@ARM.com return 0; 10569651SAndreas.Sandberg@ARM.com 10579651SAndreas.Sandberg@ARM.com case KVM_EXIT_INTERNAL_ERROR: 10589651SAndreas.Sandberg@ARM.com panic("KVM: Internal error (suberror: %u)\n", 10599651SAndreas.Sandberg@ARM.com _kvmRun->internal.suberror); 10609651SAndreas.Sandberg@ARM.com 10619651SAndreas.Sandberg@ARM.com default: 10629689Sandreas@sandberg.pp.se dump(); 10639651SAndreas.Sandberg@ARM.com panic("KVM: Unexpected exit (exit_reason: %u)\n", _kvmRun->exit_reason); 10649651SAndreas.Sandberg@ARM.com } 10659651SAndreas.Sandberg@ARM.com} 10669651SAndreas.Sandberg@ARM.com 10679651SAndreas.Sandberg@ARM.comTick 10689651SAndreas.Sandberg@ARM.comBaseKvmCPU::handleKvmExitIO() 10699651SAndreas.Sandberg@ARM.com{ 10709651SAndreas.Sandberg@ARM.com panic("KVM: Unhandled guest IO (dir: %i, size: %i, port: 0x%x, count: %i)\n", 10719651SAndreas.Sandberg@ARM.com _kvmRun->io.direction, _kvmRun->io.size, 10729651SAndreas.Sandberg@ARM.com _kvmRun->io.port, _kvmRun->io.count); 10739651SAndreas.Sandberg@ARM.com} 10749651SAndreas.Sandberg@ARM.com 10759651SAndreas.Sandberg@ARM.comTick 10769651SAndreas.Sandberg@ARM.comBaseKvmCPU::handleKvmExitHypercall() 10779651SAndreas.Sandberg@ARM.com{ 10789651SAndreas.Sandberg@ARM.com panic("KVM: Unhandled hypercall\n"); 10799651SAndreas.Sandberg@ARM.com} 10809651SAndreas.Sandberg@ARM.com 10819651SAndreas.Sandberg@ARM.comTick 10829651SAndreas.Sandberg@ARM.comBaseKvmCPU::handleKvmExitIRQWindowOpen() 10839651SAndreas.Sandberg@ARM.com{ 10849651SAndreas.Sandberg@ARM.com warn("KVM: Unhandled IRQ window.\n"); 10859651SAndreas.Sandberg@ARM.com return 0; 10869651SAndreas.Sandberg@ARM.com} 10879651SAndreas.Sandberg@ARM.com 10889651SAndreas.Sandberg@ARM.com 10899651SAndreas.Sandberg@ARM.comTick 10909651SAndreas.Sandberg@ARM.comBaseKvmCPU::handleKvmExitUnknown() 10919651SAndreas.Sandberg@ARM.com{ 10929689Sandreas@sandberg.pp.se dump(); 10939651SAndreas.Sandberg@ARM.com panic("KVM: Unknown error when starting vCPU (hw reason: 0x%llx)\n", 10949651SAndreas.Sandberg@ARM.com _kvmRun->hw.hardware_exit_reason); 10959651SAndreas.Sandberg@ARM.com} 10969651SAndreas.Sandberg@ARM.com 10979651SAndreas.Sandberg@ARM.comTick 10989651SAndreas.Sandberg@ARM.comBaseKvmCPU::handleKvmExitException() 10999651SAndreas.Sandberg@ARM.com{ 11009689Sandreas@sandberg.pp.se dump(); 11019651SAndreas.Sandberg@ARM.com panic("KVM: Got exception when starting vCPU " 11029651SAndreas.Sandberg@ARM.com "(exception: %u, error_code: %u)\n", 11039651SAndreas.Sandberg@ARM.com _kvmRun->ex.exception, _kvmRun->ex.error_code); 11049651SAndreas.Sandberg@ARM.com} 11059651SAndreas.Sandberg@ARM.com 11069651SAndreas.Sandberg@ARM.comTick 11079651SAndreas.Sandberg@ARM.comBaseKvmCPU::handleKvmExitFailEntry() 11089651SAndreas.Sandberg@ARM.com{ 11099689Sandreas@sandberg.pp.se dump(); 11109651SAndreas.Sandberg@ARM.com panic("KVM: Failed to enter virtualized mode (hw reason: 0x%llx)\n", 11119651SAndreas.Sandberg@ARM.com _kvmRun->fail_entry.hardware_entry_failure_reason); 11129651SAndreas.Sandberg@ARM.com} 11139651SAndreas.Sandberg@ARM.com 11149651SAndreas.Sandberg@ARM.comTick 11159651SAndreas.Sandberg@ARM.comBaseKvmCPU::doMMIOAccess(Addr paddr, void *data, int size, bool write) 11169651SAndreas.Sandberg@ARM.com{ 11179760Sandreas@sandberg.pp.se ThreadContext *tc(thread->getTC()); 11189760Sandreas@sandberg.pp.se syncThreadContext(); 11199760Sandreas@sandberg.pp.se 112012749Sgiacomo.travaglini@arm.com RequestPtr mmio_req = std::make_shared<Request>( 112112749Sgiacomo.travaglini@arm.com paddr, size, Request::UNCACHEABLE, dataMasterId()); 112212749Sgiacomo.travaglini@arm.com 112311629Smichael.lebeane@amd.com mmio_req->setContext(tc->contextId()); 11249760Sandreas@sandberg.pp.se // Some architectures do need to massage physical addresses a bit 11259760Sandreas@sandberg.pp.se // before they are inserted into the memory system. This enables 11269760Sandreas@sandberg.pp.se // APIC accesses on x86 and m5ops where supported through a MMIO 11279760Sandreas@sandberg.pp.se // interface. 11289760Sandreas@sandberg.pp.se BaseTLB::Mode tlb_mode(write ? BaseTLB::Write : BaseTLB::Read); 112911629Smichael.lebeane@amd.com Fault fault(tc->getDTBPtr()->finalizePhysical(mmio_req, tc, tlb_mode)); 11309760Sandreas@sandberg.pp.se if (fault != NoFault) 11319760Sandreas@sandberg.pp.se warn("Finalization of MMIO address failed: %s\n", fault->name()); 11329760Sandreas@sandberg.pp.se 11339651SAndreas.Sandberg@ARM.com 11349651SAndreas.Sandberg@ARM.com const MemCmd cmd(write ? MemCmd::WriteReq : MemCmd::ReadReq); 113511629Smichael.lebeane@amd.com PacketPtr pkt = new Packet(mmio_req, cmd); 113611629Smichael.lebeane@amd.com pkt->dataStatic(data); 11379760Sandreas@sandberg.pp.se 113811629Smichael.lebeane@amd.com if (mmio_req->isMmappedIpr()) { 113910157Sandreas@sandberg.pp.se // We currently assume that there is no need to migrate to a 114010157Sandreas@sandberg.pp.se // different event queue when doing IPRs. Currently, IPRs are 114110157Sandreas@sandberg.pp.se // only used for m5ops, so it should be a valid assumption. 11429882Sandreas@sandberg.pp.se const Cycles ipr_delay(write ? 114311629Smichael.lebeane@amd.com TheISA::handleIprWrite(tc, pkt) : 114411629Smichael.lebeane@amd.com TheISA::handleIprRead(tc, pkt)); 114510553Salexandru.dutu@amd.com threadContextDirty = true; 114611629Smichael.lebeane@amd.com delete pkt; 11479925Sandreas@sandberg.pp.se return clockPeriod() * ipr_delay; 11489760Sandreas@sandberg.pp.se } else { 114912155Sandreas.sandberg@arm.com // Temporarily lock and migrate to the device event queue to 115012155Sandreas.sandberg@arm.com // prevent races in multi-core mode. 115112155Sandreas.sandberg@arm.com EventQueue::ScopedMigration migrate(deviceEventQueue()); 115210157Sandreas@sandberg.pp.se 115311629Smichael.lebeane@amd.com return dataPort.submitIO(pkt); 11549760Sandreas@sandberg.pp.se } 11559651SAndreas.Sandberg@ARM.com} 11569651SAndreas.Sandberg@ARM.com 11579753Sandreas@sandberg.pp.sevoid 11589753Sandreas@sandberg.pp.seBaseKvmCPU::setSignalMask(const sigset_t *mask) 11599753Sandreas@sandberg.pp.se{ 11609753Sandreas@sandberg.pp.se std::unique_ptr<struct kvm_signal_mask> kvm_mask; 11619753Sandreas@sandberg.pp.se 11629753Sandreas@sandberg.pp.se if (mask) { 11639753Sandreas@sandberg.pp.se kvm_mask.reset((struct kvm_signal_mask *)operator new( 11649753Sandreas@sandberg.pp.se sizeof(struct kvm_signal_mask) + sizeof(*mask))); 11659753Sandreas@sandberg.pp.se // The kernel and the user-space headers have different ideas 11669753Sandreas@sandberg.pp.se // about the size of sigset_t. This seems like a massive hack, 11679753Sandreas@sandberg.pp.se // but is actually what qemu does. 11689753Sandreas@sandberg.pp.se assert(sizeof(*mask) >= 8); 11699753Sandreas@sandberg.pp.se kvm_mask->len = 8; 11709753Sandreas@sandberg.pp.se memcpy(kvm_mask->sigset, mask, kvm_mask->len); 11719753Sandreas@sandberg.pp.se } 11729753Sandreas@sandberg.pp.se 11739753Sandreas@sandberg.pp.se if (ioctl(KVM_SET_SIGNAL_MASK, (void *)kvm_mask.get()) == -1) 11749753Sandreas@sandberg.pp.se panic("KVM: Failed to set vCPU signal mask (errno: %i)\n", 11759753Sandreas@sandberg.pp.se errno); 11769753Sandreas@sandberg.pp.se} 11779753Sandreas@sandberg.pp.se 11789651SAndreas.Sandberg@ARM.comint 11799651SAndreas.Sandberg@ARM.comBaseKvmCPU::ioctl(int request, long p1) const 11809651SAndreas.Sandberg@ARM.com{ 11819651SAndreas.Sandberg@ARM.com if (vcpuFD == -1) 11829651SAndreas.Sandberg@ARM.com panic("KVM: CPU ioctl called before initialization\n"); 11839651SAndreas.Sandberg@ARM.com 11849651SAndreas.Sandberg@ARM.com return ::ioctl(vcpuFD, request, p1); 11859651SAndreas.Sandberg@ARM.com} 11869651SAndreas.Sandberg@ARM.com 11879651SAndreas.Sandberg@ARM.comTick 11889651SAndreas.Sandberg@ARM.comBaseKvmCPU::flushCoalescedMMIO() 11899651SAndreas.Sandberg@ARM.com{ 11909651SAndreas.Sandberg@ARM.com if (!mmioRing) 11919651SAndreas.Sandberg@ARM.com return 0; 11929651SAndreas.Sandberg@ARM.com 11939651SAndreas.Sandberg@ARM.com DPRINTF(KvmIO, "KVM: Flushing the coalesced MMIO ring buffer\n"); 11949651SAndreas.Sandberg@ARM.com 11959651SAndreas.Sandberg@ARM.com // TODO: We might need to do synchronization when we start to 11969651SAndreas.Sandberg@ARM.com // support multiple CPUs 11979651SAndreas.Sandberg@ARM.com Tick ticks(0); 11989651SAndreas.Sandberg@ARM.com while (mmioRing->first != mmioRing->last) { 11999651SAndreas.Sandberg@ARM.com struct kvm_coalesced_mmio &ent( 12009651SAndreas.Sandberg@ARM.com mmioRing->coalesced_mmio[mmioRing->first]); 12019651SAndreas.Sandberg@ARM.com 12029651SAndreas.Sandberg@ARM.com DPRINTF(KvmIO, "KVM: Handling coalesced MMIO (addr: 0x%x, len: %u)\n", 12039651SAndreas.Sandberg@ARM.com ent.phys_addr, ent.len); 12049651SAndreas.Sandberg@ARM.com 12059651SAndreas.Sandberg@ARM.com ++numCoalescedMMIO; 12069651SAndreas.Sandberg@ARM.com ticks += doMMIOAccess(ent.phys_addr, ent.data, ent.len, true); 12079651SAndreas.Sandberg@ARM.com 12089651SAndreas.Sandberg@ARM.com mmioRing->first = (mmioRing->first + 1) % KVM_COALESCED_MMIO_MAX; 12099651SAndreas.Sandberg@ARM.com } 12109651SAndreas.Sandberg@ARM.com 12119651SAndreas.Sandberg@ARM.com return ticks; 12129651SAndreas.Sandberg@ARM.com} 12139651SAndreas.Sandberg@ARM.com 12149892Sandreas@sandberg.pp.se/** 121510114Sandreas@sandberg.pp.se * Dummy handler for KVM kick signals. 121610073Sandreas@sandberg.pp.se * 121710114Sandreas@sandberg.pp.se * @note This function is usually not called since the kernel doesn't 121810073Sandreas@sandberg.pp.se * seem to deliver signals when the signal is only unmasked when 121910073Sandreas@sandberg.pp.se * running in KVM. This doesn't matter though since we are only 122010073Sandreas@sandberg.pp.se * interested in getting KVM to exit, which happens as expected. See 122110073Sandreas@sandberg.pp.se * setupSignalHandler() and kvmRun() for details about KVM signal 122210073Sandreas@sandberg.pp.se * handling. 12239892Sandreas@sandberg.pp.se */ 12249892Sandreas@sandberg.pp.sestatic void 122510114Sandreas@sandberg.pp.seonKickSignal(int signo, siginfo_t *si, void *data) 12269892Sandreas@sandberg.pp.se{ 12279892Sandreas@sandberg.pp.se} 12289892Sandreas@sandberg.pp.se 12299651SAndreas.Sandberg@ARM.comvoid 12309651SAndreas.Sandberg@ARM.comBaseKvmCPU::setupSignalHandler() 12319651SAndreas.Sandberg@ARM.com{ 12329651SAndreas.Sandberg@ARM.com struct sigaction sa; 12339651SAndreas.Sandberg@ARM.com 12349651SAndreas.Sandberg@ARM.com memset(&sa, 0, sizeof(sa)); 123510114Sandreas@sandberg.pp.se sa.sa_sigaction = onKickSignal; 12369651SAndreas.Sandberg@ARM.com sa.sa_flags = SA_SIGINFO | SA_RESTART; 123710114Sandreas@sandberg.pp.se if (sigaction(KVM_KICK_SIGNAL, &sa, NULL) == -1) 12389892Sandreas@sandberg.pp.se panic("KVM: Failed to setup vCPU timer signal handler\n"); 12399892Sandreas@sandberg.pp.se 12409753Sandreas@sandberg.pp.se sigset_t sigset; 124110073Sandreas@sandberg.pp.se if (pthread_sigmask(SIG_BLOCK, NULL, &sigset) == -1) 12429753Sandreas@sandberg.pp.se panic("KVM: Failed get signal mask\n"); 12439753Sandreas@sandberg.pp.se 12449753Sandreas@sandberg.pp.se // Request KVM to setup the same signal mask as we're currently 124510114Sandreas@sandberg.pp.se // running with except for the KVM control signal. We'll sometimes 124610114Sandreas@sandberg.pp.se // need to raise the KVM_KICK_SIGNAL to cause immediate exits from 124710114Sandreas@sandberg.pp.se // KVM after servicing IO requests. See kvmRun(). 124810114Sandreas@sandberg.pp.se sigdelset(&sigset, KVM_KICK_SIGNAL); 12499753Sandreas@sandberg.pp.se setSignalMask(&sigset); 12509753Sandreas@sandberg.pp.se 12519892Sandreas@sandberg.pp.se // Mask our control signals so they aren't delivered unless we're 12529753Sandreas@sandberg.pp.se // actually executing inside KVM. 125310114Sandreas@sandberg.pp.se sigaddset(&sigset, KVM_KICK_SIGNAL); 125410073Sandreas@sandberg.pp.se if (pthread_sigmask(SIG_SETMASK, &sigset, NULL) == -1) 12559892Sandreas@sandberg.pp.se panic("KVM: Failed mask the KVM control signals\n"); 12569753Sandreas@sandberg.pp.se} 12579753Sandreas@sandberg.pp.se 12589753Sandreas@sandberg.pp.sebool 12599753Sandreas@sandberg.pp.seBaseKvmCPU::discardPendingSignal(int signum) const 12609753Sandreas@sandberg.pp.se{ 12619753Sandreas@sandberg.pp.se int discardedSignal; 12629753Sandreas@sandberg.pp.se 12639753Sandreas@sandberg.pp.se // Setting the timeout to zero causes sigtimedwait to return 12649753Sandreas@sandberg.pp.se // immediately. 12659753Sandreas@sandberg.pp.se struct timespec timeout; 12669753Sandreas@sandberg.pp.se timeout.tv_sec = 0; 12679753Sandreas@sandberg.pp.se timeout.tv_nsec = 0; 12689753Sandreas@sandberg.pp.se 12699753Sandreas@sandberg.pp.se sigset_t sigset; 12709753Sandreas@sandberg.pp.se sigemptyset(&sigset); 12719753Sandreas@sandberg.pp.se sigaddset(&sigset, signum); 12729753Sandreas@sandberg.pp.se 12739753Sandreas@sandberg.pp.se do { 12749753Sandreas@sandberg.pp.se discardedSignal = sigtimedwait(&sigset, NULL, &timeout); 12759753Sandreas@sandberg.pp.se } while (discardedSignal == -1 && errno == EINTR); 12769753Sandreas@sandberg.pp.se 12779753Sandreas@sandberg.pp.se if (discardedSignal == signum) 12789753Sandreas@sandberg.pp.se return true; 12799753Sandreas@sandberg.pp.se else if (discardedSignal == -1 && errno == EAGAIN) 12809753Sandreas@sandberg.pp.se return false; 12819753Sandreas@sandberg.pp.se else 12829753Sandreas@sandberg.pp.se panic("Unexpected return value from sigtimedwait: %i (errno: %i)\n", 12839753Sandreas@sandberg.pp.se discardedSignal, errno); 12849651SAndreas.Sandberg@ARM.com} 12859651SAndreas.Sandberg@ARM.com 12869651SAndreas.Sandberg@ARM.comvoid 12879651SAndreas.Sandberg@ARM.comBaseKvmCPU::setupCounters() 12889651SAndreas.Sandberg@ARM.com{ 12899651SAndreas.Sandberg@ARM.com DPRINTF(Kvm, "Attaching cycle counter...\n"); 12909651SAndreas.Sandberg@ARM.com PerfKvmCounterConfig cfgCycles(PERF_TYPE_HARDWARE, 12919651SAndreas.Sandberg@ARM.com PERF_COUNT_HW_CPU_CYCLES); 12929651SAndreas.Sandberg@ARM.com cfgCycles.disabled(true) 12939651SAndreas.Sandberg@ARM.com .pinned(true); 12949655SAndreas.Sandberg@ARM.com 12959986Sandreas@sandberg.pp.se // Try to exclude the host. We set both exclude_hv and 12969986Sandreas@sandberg.pp.se // exclude_host since different architectures use slightly 12979986Sandreas@sandberg.pp.se // different APIs in the kernel. 12989986Sandreas@sandberg.pp.se cfgCycles.exclude_hv(true) 12999986Sandreas@sandberg.pp.se .exclude_host(true); 13009986Sandreas@sandberg.pp.se 13019655SAndreas.Sandberg@ARM.com if (perfControlledByTimer) { 13029655SAndreas.Sandberg@ARM.com // We need to configure the cycles counter to send overflows 13039655SAndreas.Sandberg@ARM.com // since we are going to use it to trigger timer signals that 13049655SAndreas.Sandberg@ARM.com // trap back into m5 from KVM. In practice, this means that we 13059655SAndreas.Sandberg@ARM.com // need to set some non-zero sample period that gets 13069655SAndreas.Sandberg@ARM.com // overridden when the timer is armed. 13079655SAndreas.Sandberg@ARM.com cfgCycles.wakeupEvents(1) 13089655SAndreas.Sandberg@ARM.com .samplePeriod(42); 13099655SAndreas.Sandberg@ARM.com } 13109655SAndreas.Sandberg@ARM.com 13119651SAndreas.Sandberg@ARM.com hwCycles.attach(cfgCycles, 13129651SAndreas.Sandberg@ARM.com 0); // TID (0 => currentThread) 13139651SAndreas.Sandberg@ARM.com 13149892Sandreas@sandberg.pp.se setupInstCounter(); 13159651SAndreas.Sandberg@ARM.com} 13169753Sandreas@sandberg.pp.se 13179753Sandreas@sandberg.pp.sebool 13189753Sandreas@sandberg.pp.seBaseKvmCPU::tryDrain() 13199753Sandreas@sandberg.pp.se{ 132010913Sandreas.sandberg@arm.com if (drainState() != DrainState::Draining) 13219753Sandreas@sandberg.pp.se return false; 13229753Sandreas@sandberg.pp.se 13239753Sandreas@sandberg.pp.se if (!archIsDrained()) { 13249753Sandreas@sandberg.pp.se DPRINTF(Drain, "tryDrain: Architecture code is not ready.\n"); 13259753Sandreas@sandberg.pp.se return false; 13269753Sandreas@sandberg.pp.se } 13279753Sandreas@sandberg.pp.se 13289753Sandreas@sandberg.pp.se if (_status == Idle || _status == Running) { 13299753Sandreas@sandberg.pp.se DPRINTF(Drain, 13309753Sandreas@sandberg.pp.se "tryDrain: CPU transitioned into the Idle state, drain done\n"); 133110913Sandreas.sandberg@arm.com signalDrainDone(); 13329753Sandreas@sandberg.pp.se return true; 13339753Sandreas@sandberg.pp.se } else { 13349753Sandreas@sandberg.pp.se DPRINTF(Drain, "tryDrain: CPU not ready.\n"); 13359753Sandreas@sandberg.pp.se return false; 13369753Sandreas@sandberg.pp.se } 13379753Sandreas@sandberg.pp.se} 13389753Sandreas@sandberg.pp.se 13399753Sandreas@sandberg.pp.sevoid 13409753Sandreas@sandberg.pp.seBaseKvmCPU::ioctlRun() 13419753Sandreas@sandberg.pp.se{ 13429753Sandreas@sandberg.pp.se if (ioctl(KVM_RUN) == -1) { 13439753Sandreas@sandberg.pp.se if (errno != EINTR) 13449753Sandreas@sandberg.pp.se panic("KVM: Failed to start virtual CPU (errno: %i)\n", 13459753Sandreas@sandberg.pp.se errno); 13469753Sandreas@sandberg.pp.se } 13479753Sandreas@sandberg.pp.se} 13489892Sandreas@sandberg.pp.se 13499892Sandreas@sandberg.pp.sevoid 13509892Sandreas@sandberg.pp.seBaseKvmCPU::setupInstStop() 13519892Sandreas@sandberg.pp.se{ 13529892Sandreas@sandberg.pp.se if (comInstEventQueue[0]->empty()) { 13539892Sandreas@sandberg.pp.se setupInstCounter(0); 13549892Sandreas@sandberg.pp.se } else { 13559892Sandreas@sandberg.pp.se const uint64_t next(comInstEventQueue[0]->nextTick()); 13569892Sandreas@sandberg.pp.se 13579892Sandreas@sandberg.pp.se assert(next > ctrInsts); 13589892Sandreas@sandberg.pp.se setupInstCounter(next - ctrInsts); 13599892Sandreas@sandberg.pp.se } 13609892Sandreas@sandberg.pp.se} 13619892Sandreas@sandberg.pp.se 13629892Sandreas@sandberg.pp.sevoid 13639892Sandreas@sandberg.pp.seBaseKvmCPU::setupInstCounter(uint64_t period) 13649892Sandreas@sandberg.pp.se{ 13659892Sandreas@sandberg.pp.se // No need to do anything if we aren't attaching for the first 13669892Sandreas@sandberg.pp.se // time or the period isn't changing. 13679892Sandreas@sandberg.pp.se if (period == activeInstPeriod && hwInstructions.attached()) 13689892Sandreas@sandberg.pp.se return; 13699892Sandreas@sandberg.pp.se 13709892Sandreas@sandberg.pp.se PerfKvmCounterConfig cfgInstructions(PERF_TYPE_HARDWARE, 13719892Sandreas@sandberg.pp.se PERF_COUNT_HW_INSTRUCTIONS); 13729892Sandreas@sandberg.pp.se 13739986Sandreas@sandberg.pp.se // Try to exclude the host. We set both exclude_hv and 13749986Sandreas@sandberg.pp.se // exclude_host since different architectures use slightly 13759986Sandreas@sandberg.pp.se // different APIs in the kernel. 13769986Sandreas@sandberg.pp.se cfgInstructions.exclude_hv(true) 13779986Sandreas@sandberg.pp.se .exclude_host(true); 13789986Sandreas@sandberg.pp.se 13799892Sandreas@sandberg.pp.se if (period) { 13809892Sandreas@sandberg.pp.se // Setup a sampling counter if that has been requested. 13819892Sandreas@sandberg.pp.se cfgInstructions.wakeupEvents(1) 13829892Sandreas@sandberg.pp.se .samplePeriod(period); 13839892Sandreas@sandberg.pp.se } 13849892Sandreas@sandberg.pp.se 13859892Sandreas@sandberg.pp.se // We need to detach and re-attach the counter to reliably change 13869892Sandreas@sandberg.pp.se // sampling settings. See PerfKvmCounter::period() for details. 13879892Sandreas@sandberg.pp.se if (hwInstructions.attached()) 13889892Sandreas@sandberg.pp.se hwInstructions.detach(); 13899892Sandreas@sandberg.pp.se assert(hwCycles.attached()); 13909892Sandreas@sandberg.pp.se hwInstructions.attach(cfgInstructions, 13919892Sandreas@sandberg.pp.se 0, // TID (0 => currentThread) 13929892Sandreas@sandberg.pp.se hwCycles); 13939892Sandreas@sandberg.pp.se 13949892Sandreas@sandberg.pp.se if (period) 139510114Sandreas@sandberg.pp.se hwInstructions.enableSignals(KVM_KICK_SIGNAL); 13969892Sandreas@sandberg.pp.se 13979892Sandreas@sandberg.pp.se activeInstPeriod = period; 13989892Sandreas@sandberg.pp.se} 1399