backdoor_manager.cc

Go to the documentation of this file.

/*
 * Copyright 2023 Google, Inc
 * All rights reserved
 *
 * The license below extends only to copyright in the software and shall
 * not be construed as granting a license to any other intellectual
 * property including but not limited to intellectual property relating
 * to a hardware implementation of the functionality of the software
 * licensed hereunder.  You may use the software subject to the license
 * terms below provided that you ensure that this notice is replicated
 * unmodified and in its entirety in all distributions of the software,
 * modified or unmodified, in source code or in binary form.
 *
 * 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.
 */
 
#include <utility>
 
#include "base/logging.hh"
#include "mem/backdoor_manager.hh"
 
namespace gem5
{
 
BackdoorManager::BackdoorManager(const std::vector<AddrRange> &original_ranges,
                                 const std::vector<AddrRange> &remapped_ranges)
    : originalRanges(original_ranges),
      remappedRanges(remapped_ranges),
      backdoorLists(original_ranges.size())
{
}
 
MemBackdoorPtr
BackdoorManager::getRevertedBackdoor(MemBackdoorPtr backdoor,
                                     const AddrRange &pkt_range)
{
    MemBackdoorPtr reverted_backdoor = findBackdoor(pkt_range);
    if (reverted_backdoor == nullptr) {
        reverted_backdoor = createRevertedBackdoor(backdoor, pkt_range);
    }
    return reverted_backdoor;
}
 
MemBackdoorPtr
BackdoorManager::createRevertedBackdoor(MemBackdoorPtr backdoor,
                                        const AddrRange &pkt_range)
{
    std::unique_ptr<MemBackdoor> reverted_backdoor = std::make_unique<MemBackdoor>();
    reverted_backdoor->flags(backdoor->flags());
    reverted_backdoor->ptr(backdoor->ptr());
 
    Addr addr = pkt_range.start();
    for (int i = 0; i < originalRanges.size(); ++i) {
        if (originalRanges[i].contains(addr)) {
            if (originalRanges[i].interleaved() ||
                remappedRanges[i].interleaved()) {
                return nullptr;
            }
 
            AddrRange shrinked_backdoor_range =
                backdoor->range() & remappedRanges[i];
 
            Addr backdoor_offset =
                shrinked_backdoor_range.start() - remappedRanges[i].start();
            Addr backdoor_size = shrinked_backdoor_range.size();
 
            reverted_backdoor->range(AddrRange(
                originalRanges[i].start() + backdoor_offset,
                originalRanges[i].start() + backdoor_offset + backdoor_size));
 
            Addr shrinked_offset =
                shrinked_backdoor_range.start() - backdoor->range().start();
            reverted_backdoor->ptr(backdoor->ptr() + shrinked_offset);
 
            MemBackdoorPtr reverted_backdoor_raw_ptr = reverted_backdoor.get();
            auto it = backdoorLists[i].insert(backdoorLists[i].end(),
                                              std::move(reverted_backdoor));
            backdoor->addInvalidationCallback(
                [this, i, it](const MemBackdoor &backdoor) {
                    (*it)->invalidate();  // *it is unique_ptr reverted_backdoor
                    this->backdoorLists[i].erase(it);
                });
            return reverted_backdoor_raw_ptr;
        }
    }
    // Backdoor is not valid. Return an empty one.
    panic("Target does not provide valid backdoor.");
}
 
MemBackdoorPtr
BackdoorManager::findBackdoor(const AddrRange &pkt_range) const
{
    Addr addr = pkt_range.start();
    Addr size = pkt_range.size();
    for (int i = 0; i < originalRanges.size(); ++i) {
        if (originalRanges[i].contains(addr)) {
            if (!originalRanges[i].contains(addr + size - 1)) {
                return nullptr;
            }
            for (const auto &backdoor : backdoorLists[i]) {
                if (backdoor->range().contains(addr) &&
                    backdoor->range().contains(addr + size - 1)) {
                    return backdoor.get();
                }
            }
        }
    }
    return nullptr;
}
 
}  // namespace gem5