memory_io_base.hpp

Go to the documentation of this file.

#pragma once
 
#include <asmgrader/common/byte.hpp>
#include <asmgrader/common/byte_vector.hpp>
#include <asmgrader/common/error_types.hpp>
#include <asmgrader/meta/remove_all_pointers.hpp>
#include <asmgrader/subprocess/memory/concepts.hpp>
 
#include <cstddef>
#include <cstdint>
#include <functional>
#include <span>
#include <type_traits>
 
#include <sched.h>
#include <sys/types.h>
 
namespace asmgrader {
 
class MemoryIOBase
{
public:
    explicit MemoryIOBase(pid_t pid)
        : pid_{pid} {};
    virtual ~MemoryIOBase() = default;
 
    template <MemoryReadSupported T>
    Result<T> read(std::uintptr_t address) {
        return MemoryIOSerde<T>::read(address, *this);
    }
 
    template <MemoryReadSupported T>
        requires std::is_trivial_v<T> // more complex types may have sizes that don't correspond
    Result<std::vector<T>> read_array(std::uintptr_t address, std::size_t size) {
        std::vector<T> result;
        result.reserve(size);
 
        for (std::uintptr_t current_address = address; size > 0; current_address += sizeof(T), --size) {
            result.push_back(TRY(MemoryIOSerde<T>::read(current_address, *this)));
        }
 
        return result;
    }
 
    template <MemoryReadSupported T>
        requires std::is_trivial_v<T> // more complex types may have sizes that don't correspond
    Result<std::vector<T>> read_array(std::uintptr_t address, std::function<bool(const T&)> until_predicate) {
        std::vector<T> result;
 
        for (std::uintptr_t current_address = address;; current_address += sizeof(T)) {
            T elem = TRY(MemoryIOSerde<T>::read(current_address, *this));
 
            if (!until_predicate(elem)) {
                break;
            }
 
            result.push_back(std::move(elem));
        }
 
        return result;
    }
 
    Result<NativeByteVector> read_bytes(std::uintptr_t address, std::size_t length) {
        return this->read_block_impl(address, length);
    }
 
    // FIXME: The reinterpret_cast's to/from std::uintptr_t and pointer types seems kinda bad
    template <MemoryReadSupported T>
    Result<remove_all_pointers_t<T>> read_deref_all(std::uintptr_t address) {
        if constexpr (std::is_pointer_v<T>) {
            using NextType = std::remove_pointer_t<T>;
 
            // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
            auto next_address = reinterpret_cast<std::uintptr_t>(TRY(read<T>(address)));
 
            return TRY(read_deref_all<NextType>(next_address));
        } else {
            return TRY(read<T>(address));
        }
    }
 
    template <MemoryWriteSupported T>
    Result<std::size_t> write(std::uintptr_t address, const T& data) {
        NativeByteVector bytes = MemoryIOSerde<T>::to_bytes(data);
        TRY(this->write_block_impl(address, bytes));
        return bytes.size();
    }
 
    pid_t get_pid() const { return pid_; }
 
private:
    pid_t pid_;
 
    template <typename T>
    friend struct MemoryIOSerde;
 
    virtual Result<NativeByteVector> read_until(std::uintptr_t address, const std::function<bool(Byte)>& predicate);
    virtual Result<NativeByteVector> read_until(std::uintptr_t address,
                                            const std::function<bool(std::span<const Byte>)>& predicate,
                                            std::size_t block_size);
 
    virtual Result<NativeByteVector> read_block_impl(std::uintptr_t address, std::size_t length) = 0;
    virtual Result<void> write_block_impl(std::uintptr_t address, const NativeByteVector& data) = 0;
};
 
} // namespace asmgrader