*/
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
// 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<std::pair<AddrRange, uint8_t*>> backingStore;
+ std::vector<BackingStoreEntry> backingStore;
// Prevent copying
PhysicalMemory(const PhysicalMemory&);
*
* @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);
+ 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::string& _name,
- const std::vector<AbstractMemory*>& _memories);
+ const std::vector<AbstractMemory*>& _memories,
+ bool mmap_using_noreserve);
/**
* Unmap all the backing store we have used.
*
* @return Pointers to the memory backing store
*/
- std::vector<std::pair<AddrRange, uint8_t*>> getBackingStore() const
+ std::vector<BackingStoreEntry> getBackingStore() const
{ return backingStore; }
/**
*
* @param os stream to serialize to
*/
- void serialize(std::ostream& os);
+ void serialize(CheckpointOut &cp) const override;
/**
* Serialize a specific store.
* @param range The address range of this backing store
* @param pmem The host pointer to this backing store
*/
- void serializeStore(std::ostream& os, unsigned int store_id,
- AddrRange range, uint8_t* pmem);
+ 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(Checkpoint* cp, const std::string& section);
+ void unserialize(CheckpointIn &cp) override;
/**
* Unserialize a specific backing store, identified by a section.
*/
- void unserializeStore(Checkpoint* cp, const std::string& section);
+ void unserializeStore(CheckpointIn &cp);
};