memory_mapper.hpp

Go to the documentation of this file.

//===- include/pstore/os/memory_mapper.hpp ----------------*- mode: C++ -*-===//
//*                                             *
//*  _ __ ___   ___ _ __ ___   ___  _ __ _   _  *
//* | '_ ` _ \ / _ \ '_ ` _ \ / _ \| '__| | | | *
//* | | | | | |  __/ | | | | | (_) | |  | |_| | *
//* |_| |_| |_|\___|_| |_| |_|\___/|_|   \__, | *
//*                                      |___/  *
//*                                         *
//*  _ __ ___   __ _ _ __  _ __   ___ _ __  *
//* | '_ ` _ \ / _` | '_ \| '_ \ / _ \ '__| *
//* | | | | | | (_| | |_) | |_) |  __/ |    *
//* |_| |_| |_|\__,_| .__/| .__/ \___|_|    *
//*                 |_|   |_|               *
//===----------------------------------------------------------------------===//
//
// Part of the pstore project, under the Apache License v2.0 with LLVM Exceptions.
// See https://github.com/SNSystems/pstore/blob/master/LICENSE.txt for license
// information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#ifndef PSTORE_OS_MEMORY_MAPPER_HPP
#define PSTORE_OS_MEMORY_MAPPER_HPP

#include "pstore/os/file.hpp"

namespace pstore {

    std::shared_ptr<std::uint8_t> aligned_valloc (std::size_t size, unsigned align);

    class system_page_size_interface {
    public:
        system_page_size_interface () = default;
        system_page_size_interface (system_page_size_interface &&) noexcept = default;
        system_page_size_interface (system_page_size_interface const &) = default;

        virtual ~system_page_size_interface () noexcept;

        system_page_size_interface & operator= (system_page_size_interface &&) noexcept = default;
        system_page_size_interface & operator= (system_page_size_interface const &) = default;

        virtual unsigned get () const = 0;
    };


    class system_page_size final : public system_page_size_interface {
    public:
        system_page_size () = default;
        ~system_page_size () noexcept override;

        unsigned get () const override { return size_; }

    private:
        unsigned size_ = sysconf ();
        static unsigned sysconf ();
    };


    class memory_mapper_base {
    public:
        virtual ~memory_mapper_base () = 0;

        memory_mapper_base (memory_mapper_base &&) noexcept = default;
        memory_mapper_base (memory_mapper_base const &) = default;
        memory_mapper_base & operator= (memory_mapper_base &&) noexcept = default;
        memory_mapper_base & operator= (memory_mapper_base const &) = default;

        std::shared_ptr<void> const & data () { return ptr_; }
        std::shared_ptr<void const> data () const { return ptr_; }

        bool is_writable () const { return is_writable_; }

        std::uint64_t offset () const { return offset_; }

        std::uint64_t size () const { return size_; }

        std::uint64_t end () const { return offset () + size (); }

        static unsigned long page_size (system_page_size_interface const & intf);

        virtual void read_only (void * addr, std::size_t len);

    protected:
        memory_mapper_base (std::shared_ptr<void> ptr, bool const is_writable,
                            std::uint64_t const offset, std::uint64_t const size)
                : ptr_{std::move (ptr)}
                , is_writable_{is_writable}
                , offset_{offset}
                , size_{size} {}

    private:
        void read_only_impl (void * addr, std::size_t len);

        std::shared_ptr<void> ptr_;
        bool is_writable_;
        std::uint64_t offset_;
        std::uint64_t size_;
    };

    std::ostream & operator<< (std::ostream & os, memory_mapper_base const & mm);


    class memory_mapper final : public memory_mapper_base {
    public:

        memory_mapper (file::file_handle & file, bool write_enabled, std::uint64_t offset,
                       std::uint64_t length);
        ~memory_mapper () noexcept override;

    private:
        static std::shared_ptr<void> mmap (file::file_handle & file, bool write_enabled,
                                           std::uint64_t offset, std::uint64_t length);
    };


    class in_memory_mapper : public memory_mapper_base {
    public:
        in_memory_mapper (file::in_memory & file, bool const write_enabled,
                          std::uint64_t const offset, std::uint64_t const length)
                : memory_mapper_base (pointer (file, offset), write_enabled, offset, length) {}
        ~in_memory_mapper () noexcept override;

        static std::shared_ptr<std::uint8_t> pointer (pstore::file::in_memory & file,
                                                      std::uint64_t const offset) {
            auto const p = std::static_pointer_cast<std::uint8_t> (file.data ());
            return std::shared_ptr<std::uint8_t> (p, p.get () + offset);
        }
    };

} // namespace pstore
#endif // PSTORE_OS_MEMORY_MAPPER_HPP