base.hh

Go to the documentation of this file.

/*
 * Copyright (c) 2014, 2016-2017 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 __DEV_VIRTIO_BASE_HH__
#define __DEV_VIRTIO_BASE_HH__
 
#include <functional>
 
#include "base/bitunion.hh"
#include "dev/virtio/virtio_ring.h"
#include "mem/port_proxy.hh"
#include "sim/sim_object.hh"
 
struct VirtIODeviceBaseParams;
struct VirtIODummyDeviceParams;
 
class VirtQueue;
 
template <> inline vring_used_elem
swap_byte(vring_used_elem v) {
    v.id = swap_byte(v.id);
    v.len = swap_byte(v.len);
    return v;
}
 
template <> inline vring_desc
swap_byte(vring_desc v) {
    v.addr = swap_byte(v.addr);
    v.len = swap_byte(v.len);
    v.flags = swap_byte(v.flags);
    v.next = swap_byte(v.next);
    return v;
}
 
class VirtDescriptor
{
  public:
    typedef uint16_t Index;
 
    VirtDescriptor(PortProxy &memProxy, ByteOrder bo,
            VirtQueue &queue, Index index);
    // WORKAROUND: The noexcept declaration works around a bug where
    // gcc 4.7 tries to call the wrong constructor when emplacing
    // something into a vector.
    VirtDescriptor(VirtDescriptor &&other) noexcept;
    ~VirtDescriptor() noexcept;
 
    VirtDescriptor &operator=(VirtDescriptor &&rhs) noexcept;
 
    Index index() const { return _index; }
 
    void update();
 
    void updateChain();
    void dump() const;
    void dumpChain() const;
    void read(size_t offset, uint8_t *dst, size_t size) const;
    void write(size_t offset, const uint8_t *src, size_t size);
    size_t size() const { return desc.len; }
 
    bool hasNext() const { return desc.flags & VRING_DESC_F_NEXT; }
    VirtDescriptor *next() const;
 
    bool isIncoming() const { return !isOutgoing(); }
    bool isOutgoing() const { return desc.flags & VRING_DESC_F_WRITE; }
 
 
    void chainRead(size_t offset, uint8_t *dst, size_t size) const;
    void chainWrite(size_t offset, const uint8_t *src, size_t size);
    size_t chainSize() const;
  private:
    // Remove default constructor
    VirtDescriptor();
    // Prevent copying
    VirtDescriptor(const VirtDescriptor &other);
 
    PortProxy *memProxy;
    VirtQueue *queue;
 
    ByteOrder byteOrder;
 
    Index _index;
 
    vring_desc desc;
};
 
class VirtQueue : public Serializable {
public:
    virtual ~VirtQueue() {};
 
    void serialize(CheckpointOut &cp) const override;
    void unserialize(CheckpointIn &cp) override;
 
    void setAddress(Addr address);
    Addr getAddress() const { return _address; }
 
     uint16_t getSize() const { return _size; }
 
    VirtDescriptor *getDescriptor(VirtDescriptor::Index index) {
        return &descriptors[index];
    }
    VirtDescriptor *consumeDescriptor();
    void produceDescriptor(VirtDescriptor *desc, uint32_t len);
    virtual void onNotify();
    virtual void onNotifyDescriptor(VirtDescriptor *desc) {};
    void dump() const;
    static const Addr ALIGN_BITS = 12;
    static const Addr ALIGN_SIZE = 1 << ALIGN_BITS;
  protected:
    VirtQueue(PortProxy &proxy, ByteOrder bo, uint16_t size);
 
    ByteOrder byteOrder;
 
  private:
    VirtQueue();
 
    const uint16_t _size;
    Addr _address;
    PortProxy &memProxy;
 
  private:
    template<typename T>
    class VirtRing
    {
      public:
        typedef uint16_t Flags;
        typedef uint16_t Index;
 
        struct Header {
            Flags flags;
            Index index;
        } M5_ATTR_PACKED;
 
        VirtRing<T>(PortProxy &proxy, ByteOrder bo, uint16_t size) :
            header{0, 0}, ring(size), _proxy(proxy), _base(0), byteOrder(bo)
        {}
 
        void setAddress(Addr addr) { _base = addr; }
 
        void
        readHeader()
        {
            assert(_base != 0);
            _proxy.readBlob(_base, &header, sizeof(header));
            header.flags = gtoh(header.flags, byteOrder);
            header.index = gtoh(header.index, byteOrder);
        }
 
        void
        writeHeader()
        {
            Header out;
            assert(_base != 0);
            out.flags = htog(header.flags, byteOrder);
            out.index = htog(header.index, byteOrder);
            _proxy.writeBlob(_base, &out, sizeof(out));
        }
 
        void
        read()
        {
            readHeader();
 
            /* Read and byte-swap the elements in the ring */
            T temp[ring.size()];
            _proxy.readBlob(_base + sizeof(header),
                            temp, sizeof(T) * ring.size());
            for (int i = 0; i < ring.size(); ++i)
                ring[i] = gtoh(temp[i], byteOrder);
        }
 
        void
        write()
        {
            assert(_base != 0);
            /* Create a byte-swapped copy of the ring and write it to
             * guest memory. */
            T temp[ring.size()];
            for (int i = 0; i < ring.size(); ++i)
                temp[i] = htog(ring[i], byteOrder);
            _proxy.writeBlob(_base + sizeof(header),
                             temp, sizeof(T) * ring.size());
            writeHeader();
        }
 
        Header header;
        std::vector<T> ring;
 
      private:
        // Remove default constructor
        VirtRing<T>();
 
        PortProxy &_proxy;
        Addr _base;
        ByteOrder byteOrder;
    };
 
    VirtRing<VirtDescriptor::Index> avail;
    VirtRing<struct vring_used_elem> used;
 
    uint16_t _last_avail;
 
    std::vector<VirtDescriptor> descriptors;
};
 
class VirtIODeviceBase : public SimObject
{
  public:
    typedef uint16_t QueueID;
    typedef uint32_t FeatureBits;
    typedef uint16_t VirtAddress;
    typedef uint16_t DeviceId;
 
    BitUnion8(DeviceStatus)
        Bitfield<7> failed;
        Bitfield<2> driver_ok;
        Bitfield<1> driver;
        Bitfield<0> acknowledge;
    EndBitUnion(DeviceStatus)
 
    typedef VirtIODeviceBaseParams Params;
    VirtIODeviceBase(Params *params, DeviceId id, size_t config_size,
                     FeatureBits features);
    virtual ~VirtIODeviceBase();
 
  public:
    void serialize(CheckpointOut &cp) const override;
    void unserialize(CheckpointIn &cp) override;
  protected:
    void
    kick()
    {
        assert(transKick);
        transKick();
    };
 
    void registerQueue(VirtQueue &queue);
 
 
    FeatureBits guestFeatures;
  public:
    virtual void readConfig(PacketPtr pkt, Addr cfgOffset);
    virtual void writeConfig(PacketPtr pkt, Addr cfgOffset);
 
    virtual void reset();
  protected:
    void readConfigBlob(PacketPtr pkt, Addr cfgOffset, const uint8_t *cfg);
 
    void writeConfigBlob(PacketPtr pkt, Addr cfgOffset, uint8_t *cfg);
 
    ByteOrder byteOrder;
 
  public:
    void
    registerKickCallback(const std::function<void()> &callback)
    {
        assert(!transKick);
        transKick = callback;
    }
 
 
    void onNotify(QueueID index);
 
 
    void setQueueSelect(QueueID idx) { _queueSelect = idx; }
    QueueID getQueueSelect() const { return _queueSelect; }
 
    void setQueueAddress(uint32_t address);
    uint32_t getQueueAddress() const;
 
    uint16_t getQueueSize() const { return getCurrentQueue().getSize(); }
 
    void setDeviceStatus(DeviceStatus status);
 
    DeviceStatus getDeviceStatus() const { return _deviceStatus; }
 
    void setGuestFeatures(FeatureBits features);
 
    FeatureBits getGuestFeatures() const { return guestFeatures; }
 
    const DeviceId deviceId;
 
    const size_t configSize;
 
    const FeatureBits deviceFeatures;
  private:
    const VirtQueue &getCurrentQueue() const;
    VirtQueue &getCurrentQueue();
 
    DeviceStatus _deviceStatus;
 
    QueueID _queueSelect;
 
    std::vector<VirtQueue *> _queues;
 
    std::function<void()> transKick;
};
 
class VirtIODummyDevice : public VirtIODeviceBase
{
  public:
    VirtIODummyDevice(VirtIODummyDeviceParams *params);
 
  protected:
    static const DeviceId ID_INVALID = 0x00;
};
 
#endif // __DEV_VIRTIO_BASE_HH__