storage.hpp

//===- include/pstore/core/storage.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_CORE_STORAGE_HPP
#define PSTORE_CORE_STORAGE_HPP

#include "pstore/core/address.hpp"
#include "pstore/core/region.hpp"
#include "pstore/support/aligned.hpp"
#include "pstore/support/assert.hpp"

namespace pstore {

    struct sat_entry {
        std::shared_ptr<void> value;

        region::memory_mapper_ptr region;

#ifndef NDEBUG
        bool is_valid () const noexcept {
            if (value == nullptr && region == nullptr) {
                return true;
            }

            auto * const ptr = static_cast<std::uint8_t const *> (value.get ());
            auto * const region_base = static_cast<std::uint8_t const *> (region->data ().get ());
            auto * const region_end = region_base + region->size ();
            return ptr >= region_base && ptr + address::segment_size <= region_end;
        }
#endif
    };

    static auto constexpr sat_elements = address::max_segment + 1U;
    using segment_address_table = std::array<sat_entry, sat_elements>;
    using sat_iterator = segment_address_table::iterator;
    using file_ptr = std::shared_ptr<file::file_base>;

    class storage {
    public:
        static auto constexpr full_region_size = UINT64_C (1) << 32U; // 4 Gigabytes
        static auto constexpr min_region_size = UINT64_C (1) << 22U;  // 4 Megabytes
        // Check that full_region_size is a multiple of min_region_size
        PSTORE_STATIC_ASSERT (full_region_size % min_region_size == 0);

        using region_container = std::vector<region::memory_mapper_ptr>;

        template <typename File>
        storage (std::shared_ptr<File> const & file,
                 std::unique_ptr<system_page_size_interface> && page_size,
                 std::unique_ptr<region::factory> && region_factory)
                : file_{std::static_pointer_cast<file::file_base> (file)}
                , page_size_{std::move (page_size)}
                , region_factory_{std::move (region_factory)}
                , regions_{region_factory_->init ()} {}

        template <typename File>
        explicit storage (std::shared_ptr<File> const & file)
                : file_{std::static_pointer_cast<file::file_base> (file)}
                , region_factory_{region::get_factory (
                      std::static_pointer_cast<file::file_handle> (file), full_region_size,
                      min_region_size)}
                , regions_{region_factory_->init ()} {}

        file::file_base * file () noexcept { return file_.get (); }
        file::file_base const * file () const noexcept { return file_.get (); }

        void map_bytes (std::uint64_t new_size);

        void update_master_pointers (std::size_t old_length);

        struct copy_from_store_traits {
            using in_store_pointer = std::uint8_t const *;
            using temp_pointer = std::uint8_t *;
        };
        struct copy_to_store_traits {
            using in_store_pointer = std::uint8_t *;
            using temp_pointer = std::uint8_t const *;
        };

        template <typename Traits, typename Function>
        void copy (address addr, std::size_t size, typename Traits::temp_pointer p,
                   Function copier) const;

        bool request_spans_regions (address const & addr, std::size_t size) const noexcept;

        void protect (address first, address last);

        std::shared_ptr<void const>
        segment_base (address::segment_type const segment) const noexcept {
            return segment_base_impl (*this, segment);
        }
        std::shared_ptr<void> const & segment_base (address::segment_type const segment) noexcept {
            return segment_base_impl (*this, segment);
        }

        std::shared_ptr<void const> address_to_pointer (address const addr) const noexcept {
            return address_to_pointer_impl (*this, addr);
        }
        std::shared_ptr<void> address_to_pointer (address const addr) noexcept {
            return address_to_pointer_impl (*this, addr);
        }

        template <typename T>
        std::shared_ptr<T const> address_to_pointer (typed_address<T> addr) const noexcept {
            return std::static_pointer_cast<T const> (address_to_pointer (addr.to_address ()));
        }
        template <typename T>
        std::shared_ptr<T> address_to_pointer (typed_address<T> addr) noexcept {
            return std::static_pointer_cast<T> (address_to_pointer (addr.to_address ()));
        }


        // For unit testing only.
        region_container const & regions () const { return regions_; }

    private:
        void shrink (std::uint64_t new_size);

        static sat_iterator
        slice_region_into_segments (std::shared_ptr<memory_mapper_base> const & region,
                                    sat_iterator segment_it, sat_iterator segment_end);

        template <typename Storage,
                  typename ResultType = typename inherit_const<
                      Storage, std::shared_ptr<void> const &, std::shared_ptr<void const>>::type>
        static auto segment_base_impl (Storage & storage,
                                       address::segment_type const segment) noexcept -> ResultType;

        template <typename Storage,
                  typename ResultType = typename inherit_const<Storage, std::shared_ptr<void>,
                                                               std::shared_ptr<void const>>::type>
        static auto address_to_pointer_impl (Storage & storage, address const addr) noexcept
            -> ResultType;

        std::unique_ptr<segment_address_table> sat_ = std::make_unique<segment_address_table> ();

        file_ptr file_;
        std::unique_ptr<system_page_size_interface> page_size_ =
            std::make_unique<system_page_size> ();
        std::unique_ptr<region::factory> region_factory_;
        region_container regions_;
    };

    // segment_base
    // ~~~~~~~~~~~~
    template <typename Storage, typename ResultType>
    inline auto storage::segment_base_impl (Storage & storage,
                                            address::segment_type const segment) noexcept
        -> ResultType {
        PSTORE_ASSERT (segment < storage.sat_->size ());
        auto & e = (*storage.sat_)[segment];
        PSTORE_ASSERT (e.is_valid ());
        return e.value;
    }

    // address_to_pointer
    // ~~~~~~~~~~~~~~~~~~
    template <typename Storage, typename ResultType>
    inline auto storage::address_to_pointer_impl (Storage & storage, address const addr) noexcept
        -> ResultType {
        auto segment_base = storage.segment_base (addr.segment ());
        using uint8_type = typename inherit_const<Storage, std::uint8_t>::type;
        return {segment_base,
                std::static_pointer_cast<uint8_type> (segment_base).get () + addr.offset ()};
    }

    // request_spans_regions
    // ~~~~~~~~~~~~~~~~~~~~~
    inline bool storage::request_spans_regions (address const & addr, std::size_t const size) const
        noexcept {
        (void) addr;
        if (size == 0) {
            return false;
        }
#ifdef PSTORE_ALWAYS_SPANNING
        return true;
#else
        return (*sat_)[addr.segment ()].region != (*sat_)[(addr + size - 1U).segment ()].region;
#endif // PSTORE_ALWAYS_SPANNING
    }

    // copy
    // ~~~~
    template <typename Traits, typename Function>
    void storage::copy (address const addr, std::size_t size, typename Traits::temp_pointer p,
                        Function copier) const {

        PSTORE_STATIC_ASSERT (std::numeric_limits<std::size_t>::max () <=
                              std::numeric_limits<std::uint64_t>::max ());
        address::segment_type segment = addr.segment ();
        PSTORE_STATIC_ASSERT (std::numeric_limits<decltype (segment)>::max () <= sat_elements);
        sat_entry const & segment_pointer = (*sat_)[segment];
        PSTORE_ASSERT (segment_pointer.value != nullptr && segment_pointer.region != nullptr &&
                       segment_pointer.is_valid ());

        auto in_store_ptr =
            static_cast<typename Traits::in_store_pointer> (segment_pointer.value.get ()) +
            addr.offset ();
        auto region_base =
            static_cast<typename Traits::in_store_pointer> (segment_pointer.region->data ().get ());
        PSTORE_ASSERT (in_store_ptr >= region_base &&
                       in_store_ptr <= region_base + segment_pointer.region->size ());

        std::uint64_t copy_size = segment_pointer.region->size () -
                                  static_cast<std::uintptr_t> (in_store_ptr - region_base);
        static_assert (std::numeric_limits<std::size_t>::max () <=
                           std::numeric_limits<std::uint64_t>::max (),
                       "size_t must not be larger than uint64!");
        copy_size = std::min (copy_size, std::uint64_t{size});

        // An initial copy for the tail of the first of the regions covered by the addr..addr+size
        // range.
        copier (in_store_ptr, p, copy_size);

        // Now copy the subsequent region(s).
        for (p += copy_size, size -= copy_size; size > 0; p += copy_size, size -= copy_size) {

            // We copied all of the necessary data to the previous region. Now move to the next
            // region and do the same.
            std::uint64_t const inc =
                (copy_size + address::segment_size - 1) / address::segment_size;
            PSTORE_ASSERT (inc < std::numeric_limits<address::segment_type>::max ());
            PSTORE_ASSERT (segment + inc < sat_elements);
            segment += static_cast<address::segment_type> (inc);

            region::memory_mapper_ptr const & region = (*sat_)[segment].region;
            PSTORE_ASSERT (region != nullptr);

            copy_size = std::min (static_cast<std::uint64_t> (size), region->size ());
            in_store_ptr = static_cast<typename Traits::in_store_pointer> (region->data ().get ());
            copier (in_store_ptr, p, copy_size);
        }
    }

} // namespace pstore

#endif // PSTORE_CORE_STORAGE_HPP