base.hh

Go to the documentation of this file.

/*
 * Copyright (c) 2012 ARM Limited
 * All rights reserved
 *
 * The license below extends only to copyright in the software and shall
 * not be construed as granting a license to any other intellectual
 * property including but not limited to intellectual property relating
 * to a hardware implementation of the functionality of the software
 * licensed hereunder.  You may use the software subject to the license
 * terms below provided that you ensure that this notice is replicated
 * unmodified and in its entirety in all distributions of the software,
 * modified or unmodified, in source code or in binary form.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met: redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer;
 * redistributions in binary form must reproduce the above copyright
 * notice, this list of conditions and the following disclaimer in the
 * documentation and/or other materials provided with the distribution;
 * neither the name of the copyright holders nor the names of its
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef __CPU_KVM_BASE_HH__
#define __CPU_KVM_BASE_HH__
 
#include <pthread.h>
 
#include <csignal>
#include <memory>
#include <queue>
 
#include "base/statistics.hh"
#include "cpu/kvm/perfevent.hh"
#include "cpu/kvm/timer.hh"
#include "cpu/kvm/vm.hh"
#include "cpu/base.hh"
#include "cpu/simple_thread.hh"
#include "sim/faults.hh"
 
#define KVM_KICK_SIGNAL SIGRTMIN
 
// forward declarations
class ThreadContext;
struct BaseKvmCPUParams;
 
class BaseKvmCPU : public BaseCPU
{
  public:
    BaseKvmCPU(BaseKvmCPUParams *params);
    virtual ~BaseKvmCPU();
 
    void init() override;
    void startup() override;
 
    void serializeThread(CheckpointOut &cp, ThreadID tid) const override;
    void unserializeThread(CheckpointIn &cp, ThreadID tid) override;
 
    DrainState drain() override;
    void drainResume() override;
    void notifyFork() override;
 
    void switchOut() override;
    void takeOverFrom(BaseCPU *cpu) override;
 
    void verifyMemoryMode() const override;
 
    Port &getDataPort() override { return dataPort; }
    Port &getInstPort() override { return instPort; }
 
    void wakeup(ThreadID tid = 0) override;
    void activateContext(ThreadID thread_num) override;
    void suspendContext(ThreadID thread_num) override;
    void deallocateContext(ThreadID thread_num);
    void haltContext(ThreadID thread_num) override;
 
    long getVCpuID() const { return vcpuID; }
    ThreadContext *getContext(int tn) override;
 
    Counter totalInsts() const override;
    Counter totalOps() const override;
 
    void finishMMIOPending();
 
    virtual void dump() const;
 
    void kick() const { pthread_kill(vcpuThread, KVM_KICK_SIGNAL); }
 
    SimpleThread *thread;
 
    ThreadContext *tc;
 
    KvmVM &vm;
 
  protected:
    enum Status {
        Idle,
        Running,
        RunningService,
        RunningMMIOPending,
        RunningServiceCompletion,
    };
 
    Status _status;
 
    void tick();
 
    virtual uint64_t getHostCycles() const;
 
    virtual Tick kvmRun(Tick ticks);
 
    virtual Tick kvmRunDrain();
 
    struct kvm_run *getKvmRunState() { return _kvmRun; };
 
    uint8_t *getGuestData(uint64_t offset) const {
        return (uint8_t *)_kvmRun + offset;
    };
 
    void kvmNonMaskableInterrupt();
 
    void kvmInterrupt(const struct kvm_interrupt &interrupt);
 
    void getRegisters(struct kvm_regs &regs) const;
    void setRegisters(const struct kvm_regs &regs);
    void getSpecialRegisters(struct kvm_sregs &regs) const;
    void setSpecialRegisters(const struct kvm_sregs &regs);
    void getFPUState(struct kvm_fpu &state) const;
    void setFPUState(const struct kvm_fpu &state);
    void setOneReg(uint64_t id, const void *addr);
    void setOneReg(uint64_t id, uint64_t value) { setOneReg(id, &value); }
    void setOneReg(uint64_t id, uint32_t value) { setOneReg(id, &value); }
    void getOneReg(uint64_t id, void *addr) const;
    uint64_t getOneRegU64(uint64_t id) const {
        uint64_t value;
        getOneReg(id, &value);
        return value;
    }
    uint32_t getOneRegU32(uint64_t id) const {
        uint32_t value;
        getOneReg(id, &value);
        return value;
    }
    std::string getAndFormatOneReg(uint64_t id) const;
 
    virtual void updateKvmState() = 0;
 
    virtual void updateThreadContext() = 0;
 
    void syncThreadContext();
 
    EventQueue *deviceEventQueue() { return vm.eventQueue(); }
 
    void syncKvmState();
    virtual Tick handleKvmExit();
 
    virtual Tick handleKvmExitIO();
 
    virtual Tick handleKvmExitHypercall();
 
    virtual Tick handleKvmExitIRQWindowOpen();
 
    virtual Tick handleKvmExitUnknown();
 
    virtual Tick handleKvmExitException();
 
    virtual Tick handleKvmExitFailEntry();
    virtual bool archIsDrained() const { return true; }
 
    Tick doMMIOAccess(Addr paddr, void *data, int size, bool write);
 
    void setSignalMask(const sigset_t *mask);
    int ioctl(int request, long p1) const;
    int ioctl(int request, void *p1) const {
        return ioctl(request, (long)p1);
    }
    int ioctl(int request) const {
        return ioctl(request, 0L);
    }
    class KVMCpuPort : public RequestPort
    {
 
      public:
        KVMCpuPort(const std::string &_name, BaseKvmCPU *_cpu)
            : RequestPort(_name, _cpu), cpu(_cpu), activeMMIOReqs(0)
        { }
        Tick submitIO(PacketPtr pkt);
 
        Status nextIOState() const;
 
      protected:
        BaseKvmCPU *cpu;
 
        std::queue<PacketPtr> pendingMMIOPkts;
 
        unsigned int activeMMIOReqs;
 
        bool recvTimingResp(PacketPtr pkt) override;
 
        void recvReqRetry() override;
 
    };
 
    KVMCpuPort dataPort;
 
    KVMCpuPort instPort;
 
    const bool alwaysSyncTC;
 
    bool threadContextDirty;
 
    bool kvmStateDirty;
 
    const long vcpuID;
 
    pthread_t vcpuThread;
 
  private:
    Tick flushCoalescedMMIO();
 
    void setupSignalHandler();
 
    bool discardPendingSignal(int signum) const;
 
    void startupThread();
 
    bool tryDrain();
 
    void ioctlRun();
 
    int vcpuFD;
    int vcpuMMapSize;
    struct kvm_run *_kvmRun;
    struct kvm_coalesced_mmio_ring *mmioRing;
    const long pageSize;
 
    EventFunctionWrapper tickEvent;
 
    void setupInstStop();
 
    void setupCounters();
 
    void setupInstCounter(uint64_t period = 0);
 
    uint64_t activeInstPeriod;
 
    PerfKvmCounter hwCycles;
 
    PerfKvmCounter hwInstructions;
 
    bool perfControlledByTimer;
    std::unique_ptr<BaseKvmTimer> runTimer;
 
    float hostFactor;
 
  public:
    /* @{ */
    struct StatGroup : public Stats::Group {
        StatGroup(Stats::Group *parent);
        Stats::Scalar committedInsts;
        Stats::Scalar numVMExits;
        Stats::Scalar numVMHalfEntries;
        Stats::Scalar numExitSignal;
        Stats::Scalar numMMIO;
        Stats::Scalar numCoalescedMMIO;
        Stats::Scalar numIO;
        Stats::Scalar numHalt;
        Stats::Scalar numInterrupts;
        Stats::Scalar numHypercalls;
    } stats;
    /* @} */
 
    Counter ctrInsts;
};
 
#endif