| /* | |
| * Copyright (c) 2017 Advanced Micro Devices, Inc. | |
| * All rights reserved. | |
| * | |
| * 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. | |
| * | |
| * Author: Brandon Potter | |
| */ | |
| #ifndef SRC_SIM_MEM_STATE_HH | |
| #define SRC_SIM_MEM_STATE_HH | |
| #include <list> | |
| #include <memory> | |
| #include <string> | |
| #include <vector> | |
| #include <sys/mman.h> | |
| #include "mem/page_table.hh" | |
| #include "mem/se_translating_port_proxy.hh" | |
| #include "mem/vma.hh" | |
| #include "sim/serialize.hh" | |
| class Process; | |
| class ProcessParams; | |
| class System; | |
| /** | |
| * This class holds the memory state for the Process class and all of its | |
| * derived, architecture-specific children. | |
| * | |
| * The class fields change dynamically as the process object is run in the | |
| * simulator. They are updated by system calls and faults. Each change | |
| * represents a modification to the process address space. | |
| * | |
| * The class is meant to be allocated dynamically and shared through a | |
| * pointer interface. Multiple process can potentially share their virtual | |
| * address space if specific options are passed into the clone(2) system call. | |
| */ | |
| class MemState : public Serializable | |
| { | |
| public: | |
| MemState(Process *owner, Addr brk_point, Addr stack_base, | |
| Addr max_stack_size, Addr next_thread_stack_base, | |
| Addr mmap_end, System *system, | |
| std::shared_ptr<EmulationPageTable> p_table, | |
| Addr vsyscall_point = 0, Addr vsyscall_size = 0); | |
| MemState& operator=(const MemState &in); | |
| void addOwner(Process *owner); | |
| void removeOwner(Process *owner); | |
| Addr getBrkPoint() const { return _brkPoint; } | |
| Addr getStackBase() const { return _stackBase; } | |
| Addr getStackSize() const { return _stackSize; } | |
| Addr getMaxStackSize() const { return _maxStackSize; } | |
| Addr getStackMin() const { return _stackMin; } | |
| Addr getNextThreadStackBase() const { return _nextThreadStackBase; } | |
| Addr getMmapEnd() const { return _mmapEnd; } | |
| void setBrkPoint(Addr brk_point) { _brkPoint = brk_point; } | |
| void setStackBase(Addr stack_base) { _stackBase = stack_base; } | |
| void setStackSize(Addr stack_size) { _stackSize = stack_size; } | |
| void setMaxStackSize(Addr max_stack) { _maxStackSize = max_stack; } | |
| void setStackMin(Addr stack_min) { _stackMin = stack_min; } | |
| void setNextThreadStackBase(Addr ntsb) { _nextThreadStackBase = ntsb; } | |
| void setMmapEnd(Addr mmap_end) { _mmapEnd = mmap_end; } | |
| const SETranslatingPortProxy& getVirtMem() const { return _virtMem; } | |
| void mapVMARegion(Addr start_addr, Addr length, int sim_fd, | |
| Addr offset, std::string vma_name); | |
| void unmapVMARegion(Addr start_addr, Addr length); | |
| void remapVMARegion(Addr start_addr, Addr new_start_addr, Addr length); | |
| void updateBrkRegion(Addr old_brk, Addr new_brk); | |
| /** | |
| * This method returns a flag which specifies the direction of growth for | |
| * the mmap region in process address space. | |
| * | |
| * @return true if the mmap region grows downward and false otherwise | |
| */ | |
| virtual bool mmapGrowsDown() const | |
| #if THE_ISA == ALPHA_ISA || THE_ISA == RISCV_ISA | |
| { return false; } | |
| #else | |
| { return true; } | |
| #endif | |
| /** | |
| * These methods perform the same behavior as the methods in the | |
| * PageTable class with the additional semantic that they will attempt to | |
| * allocate physical pages (frames) to resolve faults. | |
| * vaddr is valid but the page table does not have an entry yet. | |
| */ | |
| bool translate(Addr va); | |
| bool translate(Addr va, Addr &pa); | |
| const EmulationPageTable::Entry *lookup(Addr va); | |
| /** | |
| * Maps a contiguous range of virtual addresses in this process's | |
| * address space to a contiguous range of physical addresses. | |
| * This function exists primarily to expose the map operation to | |
| * python, so that configuration scripts can set up mappings in SE mode. | |
| * | |
| * @param vaddr The starting virtual address of the range. | |
| * @param paddr The starting physical address of the range. | |
| * @param size The length of the range in bytes. | |
| * @param cacheable Specifies whether accesses are cacheable. | |
| * @return True if the map operation was successful. (At this point in | |
| * time, the map operation always succeeds.) | |
| */ | |
| bool map(Addr vaddr, Addr paddr, int size, bool cacheable = true); | |
| /** | |
| * Attempt to fix up a fault at vaddr by allocating a page. The fault | |
| * likely occurred because a virtual page which does not have physical | |
| * page assignment is being accessed. | |
| * | |
| * @param vaddr The virtual address which is causing the fault. | |
| * @return Whether the fault has been fixed. | |
| */ | |
| bool fixupFault(Addr vaddr); | |
| /** | |
| * Given the vaddr and size, this method will chunk the allocation into | |
| * page granularity and then request physical pages (frames) from the | |
| * system object. After retrieving a frame, the method updates the page | |
| * table mappings. | |
| * | |
| * @param vaddr The virtual address in need of a frame allocation. | |
| * @param size The size in bytes of the requested mapping. | |
| * @param clobber This flag specifies whether mappings in the page tables | |
| * can be overwritten and replaced with the new mapping. | |
| */ | |
| void allocateMem(Addr vaddr, int64_t size, bool clobber = false); | |
| /** | |
| * The _pTable member is either an architectural page table object or a | |
| * functional page table object. Both implementations share the same API | |
| * and can be accessed through this base class object. | |
| */ | |
| std::shared_ptr<EmulationPageTable> _pTable; | |
| /** | |
| * This port proxy provides a handle to access the process address space | |
| * (represented by this object). In SE Mode, all references to the | |
| * process address space (using virtual addresses) should be directed | |
| * through this proxy. | |
| * | |
| * Creating duplicates or storing copies of this proxy in other | |
| * objects is frowned upon; please do not do it! Note, the proxy is | |
| * owned by this object and will become obsolete if this object | |
| * deconstructs. (This will happen if all processes release their hold | |
| * on this object; this is particularly an issue when calling the exec | |
| * system call.) | |
| */ | |
| const SETranslatingPortProxy& getVirtProxy() { return _virtMem; } | |
| void | |
| serialize(CheckpointOut &cp) const override | |
| { | |
| paramOut(cp, "brkPoint", _brkPoint); | |
| paramOut(cp, "stackBase", _stackBase); | |
| paramOut(cp, "stackSize", _stackSize); | |
| paramOut(cp, "maxStackSize", _maxStackSize); | |
| paramOut(cp, "stackMin", _stackMin); | |
| paramOut(cp, "nextThreadStackBase", _nextThreadStackBase); | |
| paramOut(cp, "mmapEnd", _mmapEnd); | |
| } | |
| void | |
| unserialize(CheckpointIn &cp) override | |
| { | |
| paramIn(cp, "brkPoint", _brkPoint); | |
| paramIn(cp, "stackBase", _stackBase); | |
| paramIn(cp, "stackSize", _stackSize); | |
| paramIn(cp, "maxStackSize", _maxStackSize); | |
| paramIn(cp, "stackMin", _stackMin); | |
| paramIn(cp, "nextThreadStackBase", _nextThreadStackBase); | |
| paramIn(cp, "mmapEnd", _mmapEnd); | |
| } | |
| const std::list<VMA> & vmaList() { return _vmaList; } | |
| private: | |
| void replicatePage(const MemState &in, Addr vaddr, Addr new_paddr, | |
| bool alloc_page); | |
| void updateTLBs(); | |
| System * system() const; | |
| void checkAlign(Addr start, Addr length); | |
| /** | |
| * Holds the list of Process objects which have a reference to this | |
| * MemState object. The owner Processes act as parents in an object tree | |
| * for MemState. | |
| */ | |
| std::vector<Process*> _ownerProcesses; | |
| Addr _brkPoint; | |
| Addr _stackBase; | |
| Addr _stackSize; | |
| Addr _maxStackSize; | |
| Addr _stackMin; | |
| Addr _nextThreadStackBase; | |
| Addr _mmapEnd; | |
| Addr _vsyscallPoint; | |
| Addr _vsyscallSize; | |
| /** | |
| * Keeps record of the furthest mapped heap location for the VMAs. | |
| */ | |
| Addr _endBrkPoint; | |
| /** | |
| * The _vmaList member is a list of virtual memory areas in the target | |
| * application space that have been allocated by the target. In most | |
| * operating systems, lazy allocation is used and these structures (or | |
| * equivalent ones) are used to track the valid address ranges. | |
| * | |
| * This could use a more efficient data structure like an interval | |
| * tree, but it is unclear whether the vmas will be modified often enough | |
| * for the improvement in lookup time to matter. | |
| */ | |
| std::list<VMA> _vmaList; | |
| /** | |
| * The _virtMem member acts as a proxy for accessing virtual memory. This | |
| * handle is responsible for reading and writing blobs and strings both to | |
| * and from the virtual memory space for Process objects. | |
| */ | |
| SETranslatingPortProxy _virtMem; | |
| }; | |
| #endif |