mem_state.hh

Go to the documentation of this file.

/*
 * 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;
 
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);
 
    void resetOwner(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; }
 
    /*
     * 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);
 
    bool isUnmapped(Addr start_addr, Addr length);
 
    void mapRegion(Addr start_addr, Addr length,
                   const std::string& name="anon", int sim_fd=-1,
                   Addr offset=0);
 
    void unmapRegion(Addr start_addr, Addr length);
 
    void remapRegion(Addr start_addr, Addr new_start_addr, Addr length);
 
    void updateBrkRegion(Addr old_brk, Addr new_brk);
 
    bool fixupFault(Addr vaddr);
 
    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);
        }
    }
 
    std::string printVmaList();
 
  private:
    void replicatePage(const MemState &in, Addr vaddr, Addr new_paddr,
                       bool alloc_page);
 
    System * system() const;
 
    Process * _ownerProcess;
 
    Addr _pageBytes;
    Addr _brkPoint;
    Addr _stackBase;
    Addr _stackSize;
    Addr _maxStackSize;
    Addr _stackMin;
    Addr _nextThreadStackBase;
    Addr _mmapEnd;
 
    Addr _endBrkPoint;
 
    std::list<VMA> _vmaList;
};
 
} // namespace gem5
 
#endif