src/sim/mem_state.hh - public/gem5 - Git at Google

 /*
  * Copyright (c) 2017-2020 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.
  */

 #ifndef SRC_SIM_MEM_STATE_HH
 #define SRC_SIM_MEM_STATE_HH

 #include <fcntl.h>
 #include <unistd.h>

 #include <list>
 #include <memory>
 #include <string>
 #include <vector>

 #include "debug/Vma.hh"
 #include "mem/page_table.hh"
 #include "mem/se_translating_port_proxy.hh"
 #include "sim/serialize.hh"
 #include "sim/vma.hh"

 namespace gem5
 {

 class Process;
 struct ProcessParams;
 class System;

 /**
  * This class holds the memory state for the Process class and all of its
  * derived, architecture-specific children.
  *
  * The class represents the Process' address space which may change
  * dynamically while the simulation is running. 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 portions of 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);

     MemState& operator=(const MemState &in);

     /**
      * Change the Process owner in case this MemState is copied.
      */
     void resetOwner(Process *owner);

     /**
      * Get/set base addresses and sizes for the stack and data segments of
      * the process' memory.
      */
     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; }

     /*
      * Extend the end of the mmap region by length bytes. Once a contiguous
      * region of free virtual memory is found the start of that region is
      * returned.
      */
     Addr extendMmap(Addr length);

     /**
      * Check if any page in the virtual address range from start_addr to
      * start_addr + length is already mapped in the page table.
      *
      * @param start_addr Starting address of region to check.
      * @param length Length of the range to check.
      *
      * @return true if all pages in the range are unmapped in page table
      */
     bool isUnmapped(Addr start_addr, Addr length);

     /**
      * Add a new memory region. The region represents a contiguous virtual
      * address range which can map to physical memory or a host-backed file.
      * Regions which are not file-backed should use -1 for sim_fd and 0 for
      * offset.
      *
      * @param start_addr Starting address of the region.
      * @param length Size of the region.
      * @param name Name of region. Optional.
      * @param sim_fd File descriptor for file-backed regions or -1.
      * @param offset Offset in file in which region starts.
      */
     void mapRegion(Addr start_addr, Addr length,
                    const std::string& name="anon", int sim_fd=-1,
                    Addr offset=0);

     /**
      * Unmap a pre-existing region. Depending on the range being unmapped
      * the resulting new regions will either be split, resized, or
      * removed completely.
      *
      * @param start_addr Starting address of region to unmap.
      * @param length Size of region to unmap.
      */
     void unmapRegion(Addr start_addr, Addr length);

     /**
      * Remap a pre-existing region. This changes the virtual address
      * range of the region. This will result in regions being expanded
      * if there is overlap with another region or simply moving the range
      * otherwise.
      *
      * @param start_addr Start address of region being remapped.
      * @param new_start_addr New start address of the region.
      * @param length Length of the newly remapped region.
      */
     void remapRegion(Addr start_addr, Addr new_start_addr, Addr length);

     /**
      * Change the end of a process' program break. This represents the end
      * of the heap segment of a process.
      *
      * @param old_brk Old program break address
      * @param new_brk New program break address
      */
     void updateBrkRegion(Addr old_brk, Addr new_brk);

     /**
      * 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);

     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);

         ScopedCheckpointSection sec(cp, "vmalist");
         paramOut(cp, "size", _vmaList.size());
         int count = 0;
         for (auto vma : _vmaList) {
             ScopedCheckpointSection sec(cp, csprintf("Vma%d", count++));
             paramOut(cp, "name", vma.getName());
             if (vma.hasHostBuf()) {
                 paramOut(cp, "fileOffset", vma.getFileMappingOffset());
             }
             paramOut(cp, "addrRangeStart", vma.start());
             paramOut(cp, "addrRangeEnd", vma.end());
         }
     }

     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);

         int count;
         ScopedCheckpointSection sec(cp, "vmalist");
         paramIn(cp, "size", count);
         for (int i = 0; i < count; ++i) {
             ScopedCheckpointSection sec(cp, csprintf("Vma%d", i));
             std::string name;
             Addr start;
             Addr end;
             off_t offset = 0;
             int host_fd = -1;
             paramIn(cp, "name", name);
             if (optParamIn(cp, "fileOffset", offset, false)) {
                 host_fd = open(name.c_str(), O_RDONLY);
                 fatal_if(host_fd < 0,
                          "Failed to open %s file "
                          "while unserializing file-backed VMA\n", name);
             }
             paramIn(cp, "addrRangeStart", start);
             paramIn(cp, "addrRangeEnd", end);
             _vmaList.emplace_back(AddrRange(start, end), _pageBytes, name,
                                   host_fd, offset);
             close(host_fd);
         }
     }

     /**
      * Print the list of VMAs in a format similar to /proc/self/maps
      */
     std::string printVmaList();

   private:
     /**
      * @param
      */
     void replicatePage(const MemState &in, Addr vaddr, Addr new_paddr,
                        bool alloc_page);

     /**
      * @param
      */
     System * system() const;

     /**
      * Owner process of MemState. Used to manipulate page tables.
      */
     Process * _ownerProcess;

     Addr _pageBytes;
     Addr _brkPoint;
     Addr _stackBase;
     Addr _stackSize;
     Addr _maxStackSize;
     Addr _stackMin;
     Addr _nextThreadStackBase;
     Addr _mmapEnd;

     /**
      * Keeps record of the furthest mapped heap location.
      */
     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. Unmapping VMAs currently
      * modifies the list while iterating so the STL container must either
      * support this or the unmapping method must be changed.
      */
     std::list<VMA> _vmaList;
 };

 } // namespace gem5

 #endif
	/*
	* Copyright (c) 2017-2020 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.
	*/

	#ifndef SRC_SIM_MEM_STATE_HH
	#define SRC_SIM_MEM_STATE_HH

	#include <fcntl.h>
	#include <unistd.h>

	#include <list>
	#include <memory>
	#include <string>
	#include <vector>

	#include "debug/Vma.hh"
	#include "mem/page_table.hh"
	#include "mem/se_translating_port_proxy.hh"
	#include "sim/serialize.hh"
	#include "sim/vma.hh"

	namespace gem5
	{

	class Process;
	struct ProcessParams;
	class System;

	/**
	* This class holds the memory state for the Process class and all of its
	* derived, architecture-specific children.
	*
	* The class represents the Process' address space which may change
	* dynamically while the simulation is running. 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 portions of 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);

	MemState& operator=(const MemState &in);

	/**
	* Change the Process owner in case this MemState is copied.
	*/
	void resetOwner(Process *owner);

	/**
	* Get/set base addresses and sizes for the stack and data segments of
	* the process' memory.
	*/
	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; }

	/*
	* Extend the end of the mmap region by length bytes. Once a contiguous
	* region of free virtual memory is found the start of that region is
	* returned.
	*/
	Addr extendMmap(Addr length);

	/**
	* Check if any page in the virtual address range from start_addr to
	* start_addr + length is already mapped in the page table.
	*
	* @param start_addr Starting address of region to check.
	* @param length Length of the range to check.
	*
	* @return true if all pages in the range are unmapped in page table
	*/
	bool isUnmapped(Addr start_addr, Addr length);

	/**
	* Add a new memory region. The region represents a contiguous virtual
	* address range which can map to physical memory or a host-backed file.
	* Regions which are not file-backed should use -1 for sim_fd and 0 for
	* offset.
	*
	* @param start_addr Starting address of the region.
	* @param length Size of the region.
	* @param name Name of region. Optional.
	* @param sim_fd File descriptor for file-backed regions or -1.
	* @param offset Offset in file in which region starts.
	*/
	void mapRegion(Addr start_addr, Addr length,
	const std::string& name="anon", int sim_fd=-1,
	Addr offset=0);

	/**
	* Unmap a pre-existing region. Depending on the range being unmapped
	* the resulting new regions will either be split, resized, or
	* removed completely.
	*
	* @param start_addr Starting address of region to unmap.
	* @param length Size of region to unmap.
	*/
	void unmapRegion(Addr start_addr, Addr length);

	/**
	* Remap a pre-existing region. This changes the virtual address
	* range of the region. This will result in regions being expanded
	* if there is overlap with another region or simply moving the range
	* otherwise.
	*
	* @param start_addr Start address of region being remapped.
	* @param new_start_addr New start address of the region.
	* @param length Length of the newly remapped region.
	*/
	void remapRegion(Addr start_addr, Addr new_start_addr, Addr length);

	/**
	* Change the end of a process' program break. This represents the end
	* of the heap segment of a process.
	*
	* @param old_brk Old program break address
	* @param new_brk New program break address
	*/
	void updateBrkRegion(Addr old_brk, Addr new_brk);

	/**
	* 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);

	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);

	ScopedCheckpointSection sec(cp, "vmalist");
	paramOut(cp, "size", _vmaList.size());
	int count = 0;
	for (auto vma : _vmaList) {
	ScopedCheckpointSection sec(cp, csprintf("Vma%d", count++));
	paramOut(cp, "name", vma.getName());
	if (vma.hasHostBuf()) {
	paramOut(cp, "fileOffset", vma.getFileMappingOffset());
	}
	paramOut(cp, "addrRangeStart", vma.start());
	paramOut(cp, "addrRangeEnd", vma.end());
	}
	}

	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);

	int count;
	ScopedCheckpointSection sec(cp, "vmalist");
	paramIn(cp, "size", count);
	for (int i = 0; i < count; ++i) {
	ScopedCheckpointSection sec(cp, csprintf("Vma%d", i));
	std::string name;
	Addr start;
	Addr end;
	off_t offset = 0;
	int host_fd = -1;
	paramIn(cp, "name", name);
	if (optParamIn(cp, "fileOffset", offset, false)) {
	host_fd = open(name.c_str(), O_RDONLY);
	fatal_if(host_fd < 0,
	"Failed to open %s file "
	"while unserializing file-backed VMA\n", name);
	}
	paramIn(cp, "addrRangeStart", start);
	paramIn(cp, "addrRangeEnd", end);
	_vmaList.emplace_back(AddrRange(start, end), _pageBytes, name,
	host_fd, offset);
	close(host_fd);
	}
	}

	/**
	* Print the list of VMAs in a format similar to /proc/self/maps
	*/
	std::string printVmaList();

	private:
	/**
	* @param
	*/
	void replicatePage(const MemState &in, Addr vaddr, Addr new_paddr,
	bool alloc_page);

	/**
	* @param
	*/
	System * system() const;

	/**
	* Owner process of MemState. Used to manipulate page tables.
	*/
	Process * _ownerProcess;

	Addr _pageBytes;
	Addr _brkPoint;
	Addr _stackBase;
	Addr _stackSize;
	Addr _maxStackSize;
	Addr _stackMin;
	Addr _nextThreadStackBase;
	Addr _mmapEnd;

	/**
	* Keeps record of the furthest mapped heap location.
	*/
	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. Unmapping VMAs currently
	* modifies the list while iterating so the STL container must either
	* support this or the unmapping method must be changed.
	*/
	std::list<VMA> _vmaList;
	};

	} // namespace gem5

	#endif