* Authors: Andreas Hansson
*/
-#ifndef __PHYSICAL_MEMORY_HH__
-#define __PHYSICAL_MEMORY_HH__
+#ifndef __MEM_PHYSICAL_HH__
+#define __MEM_PHYSICAL_HH__
#include "base/addr_range_map.hh"
-#include "mem/abstract_mem.hh"
#include "mem/packet.hh"
+/**
+ * Forward declaration to avoid header dependencies.
+ */
+class AbstractMemory;
+
+/**
+ * A single entry for the backing store.
+ */
+class BackingStoreEntry
+{
+ public:
+
+ /**
+ * Create a backing store entry. Don't worry about managing the memory
+ * pointers, because PhysicalMemory is responsible for that.
+ */
+ BackingStoreEntry(AddrRange range, uint8_t* pmem,
+ bool conf_table_reported, bool in_addr_map, bool kvm_map)
+ : range(range), pmem(pmem), confTableReported(conf_table_reported),
+ inAddrMap(in_addr_map), kvmMap(kvm_map)
+ {}
+
+ /**
+ * The address range covered in the guest.
+ */
+ AddrRange range;
+
+ /**
+ * Pointer to the host memory this range maps to. This memory is the same
+ * size as the range field.
+ */
+ uint8_t* pmem;
+
+ /**
+ * Whether this memory should be reported to the configuration table
+ */
+ bool confTableReported;
+
+ /**
+ * Whether this memory should appear in the global address map
+ */
+ bool inAddrMap;
+
+ /**
+ * Whether KVM should map this memory into the guest address space during
+ * acceleration.
+ */
+ bool kvmMap;
+};
+
/**
* The physical memory encapsulates all memories in the system and
* provides basic functionality for accessing those memories without
* going through the memory system and interconnect.
+ *
+ * The physical memory is also responsible for providing the host
+ * system backingstore used by the memories in the simulated guest
+ * system. When the system is created, the physical memory allocates
+ * the backing store based on the address ranges that are populated in
+ * the system, and does so independent of how those map to actual
+ * memory controllers. Thus, the physical memory completely abstracts
+ * the mapping of the backing store of the host system and the address
+ * mapping in the guest system. This enables us to arbitrarily change
+ * the number of memory controllers, and their address mapping, as
+ * long as the ranges stay the same.
*/
-class PhysicalMemory
+class PhysicalMemory : public Serializable
{
private:
+ // Name for debugging
+ std::string _name;
+
// Global address map
AddrRangeMap<AbstractMemory*> addrMap;
- // a mutable cache for the last range that matched an address
- mutable AddrRange rangeCache;
+ // a mutable cache for the last address map iterator that matched
+ // an address
+ mutable AddrRangeMap<AbstractMemory*>::const_iterator rangeCache;
// All address-mapped memories
std::vector<AbstractMemory*> memories;
// The total memory size
uint64_t size;
+ // Let the user choose if we reserve swap space when calling mmap
+ const bool mmapUsingNoReserve;
+
+ // The physical memory used to provide the memory in the simulated
+ // system
+ std::vector<BackingStoreEntry> backingStore;
+
// Prevent copying
PhysicalMemory(const PhysicalMemory&);
// Prevent assignment
PhysicalMemory& operator=(const PhysicalMemory&);
+ /**
+ * Create the memory region providing the backing store for a
+ * given address range that corresponds to a set of memories in
+ * the simulated system.
+ *
+ * @param range The address range covered
+ * @param memories The memories this range maps to
+ * @param kvm_map Should KVM map this memory for the guest
+ */
+ void createBackingStore(AddrRange range,
+ const std::vector<AbstractMemory*>& _memories,
+ bool conf_table_reported,
+ bool in_addr_map, bool kvm_map);
+
public:
/**
* Create a physical memory object, wrapping a number of memories.
*/
- PhysicalMemory(const std::vector<AbstractMemory*>& _memories);
+ PhysicalMemory(const std::string& _name,
+ const std::vector<AbstractMemory*>& _memories,
+ bool mmap_using_noreserve);
/**
- * Nothing to destruct.
+ * Unmap all the backing store we have used.
*/
- ~PhysicalMemory() { }
+ ~PhysicalMemory();
+
+ /**
+ * Return the name for debugging and for creation of sections for
+ * checkpointing.
+ */
+ const std::string name() const { return _name; }
/**
* Check if a physical address is within a range of a memory that
/**
* Get the memory ranges for all memories that are to be reported
- * to the configuration table.
+ * to the configuration table. The ranges are merged before they
+ * are returned such that any interleaved ranges appear as a
+ * single range.
*
* @return All configuration table memory ranges
*/
*/
uint64_t totalSize() const { return size; }
+ /**
+ * Get the pointers to the backing store for external host
+ * access. Note that memory in the guest should be accessed using
+ * access() or functionalAccess(). This interface is primarily
+ * intended for CPU models using hardware virtualization. Note
+ * that memories that are null are not present, and that the
+ * backing store may also contain memories that are not part of
+ * the OS-visible global address map and thus are allowed to
+ * overlap.
+ *
+ * @return Pointers to the memory backing store
+ */
+ std::vector<BackingStoreEntry> getBackingStore() const
+ { return backingStore; }
+
/**
+ * Perform an untimed memory access and update all the state
+ * (e.g. locked addresses) and statistics accordingly. The packet
+ * is turned into a response if required.
*
+ * @param pkt Packet performing the access
*/
void access(PacketPtr pkt);
+
+ /**
+ * Perform an untimed memory read or write without changing
+ * anything but the memory itself. No stats are affected by this
+ * access. In addition to normal accesses this also facilitates
+ * print requests.
+ *
+ * @param pkt Packet performing the access
+ */
void functionalAccess(PacketPtr pkt);
-};
+ /**
+ * Serialize all the memories in the system. This is independent
+ * of the logical memory layout, and the serialization only sees
+ * the contigous backing store, independent of how this maps to
+ * logical memories in the guest system.
+ *
+ * @param os stream to serialize to
+ */
+ void serialize(CheckpointOut &cp) const override;
+ /**
+ * Serialize a specific store.
+ *
+ * @param store_id Unique identifier of this backing store
+ * @param range The address range of this backing store
+ * @param pmem The host pointer to this backing store
+ */
+ void serializeStore(CheckpointOut &cp, unsigned int store_id,
+ AddrRange range, uint8_t* pmem) const;
+ /**
+ * Unserialize the memories in the system. As with the
+ * serialization, this action is independent of how the address
+ * ranges are mapped to logical memories in the guest system.
+ */
+ void unserialize(CheckpointIn &cp) override;
+
+ /**
+ * Unserialize a specific backing store, identified by a section.
+ */
+ void unserializeStore(CheckpointIn &cp);
+
+};
-#endif //__PHYSICAL_MEMORY_HH__
+#endif //__MEM_PHYSICAL_HH__
projects / gem5.git / blobdiff