file_header.hpp

Go to the documentation of this file.

//===- include/pstore/core/file_header.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_FILE_HEADER_HPP
#define PSTORE_CORE_FILE_HEADER_HPP

#include <atomic>

#include "pstore/core/address.hpp"
#include "pstore/core/uuid.hpp"
#include "pstore/serialize/types.hpp"

namespace pstore {

    namespace serialize {
        template <typename T>
        struct serializer<extent<T>> {
            using value_type = extent<T>;

            template <typename Archive>
            static auto write (Archive && archive, value_type const & r)
                -> archive_result_type<Archive> {
                auto const resl =
                    serialize::write (std::forward<Archive> (archive), r.addr.absolute ());
                serialize::write (std::forward<Archive> (archive), r.size);
                return resl;
            }
            template <typename Archive>
            static void read (Archive && archive, value_type & r) {
                auto const addr = typed_address<T>::make (
                    serialize::read<std::uint64_t> (std::forward<Archive> (archive)));
                auto const size = serialize::read<std::uint64_t> (std::forward<Archive> (archive));
                new (&r) extent<T> (addr, size);
            }
        };
    } // namespace serialize

    struct trailer;

    class header {
    public:
        header ();

        bool is_valid () const noexcept;

        std::uint32_t get_crc () const noexcept;

        uuid id () const noexcept { return a.id; }
        void set_id (uuid const & id) noexcept;

        std::array<std::uint16_t, 2> const & version () const noexcept { return a.version; }

        static constexpr std::uint16_t major_version = 1;
        static constexpr std::uint16_t minor_version = 12;

        static std::array<std::uint8_t, 4> const file_signature1;
        static std::uint32_t const file_signature2 = 0x0507FFFF;

        struct body {

            std::array<std::uint8_t, 4> signature1;

            std::uint32_t signature2;

            std::array<std::uint16_t, 2> version;
            std::uint32_t header_size = sizeof (header);
            class uuid id;
        };

        body a;

        std::uint32_t crc = 0;
        std::uint32_t unused1 = 0;

        std::atomic<typed_address<trailer>> footer_pos;
    };

    // Assert the size, offset, and alignment of the structure and its fields to ensure file format
    // compatibility across compilers and hosts.
    PSTORE_STATIC_ASSERT (offsetof (header::body, signature1) == 0);
    PSTORE_STATIC_ASSERT (offsetof (header::body, signature2) == 4);
    PSTORE_STATIC_ASSERT (offsetof (header::body, version) == 8);
    PSTORE_STATIC_ASSERT (offsetof (header::body, header_size) == 12);
    PSTORE_STATIC_ASSERT (offsetof (header::body, id) == 16);
    PSTORE_STATIC_ASSERT (sizeof (header::body) == 32);

    PSTORE_STATIC_ASSERT (offsetof (header, a) == 0);
    PSTORE_STATIC_ASSERT (offsetof (header, crc) == 32);
    PSTORE_STATIC_ASSERT (offsetof (header, footer_pos) == 40);
    PSTORE_STATIC_ASSERT (alignof (header) == 8);
    PSTORE_STATIC_ASSERT (sizeof (header) == 48);

    struct lock_block {
        std::uint64_t vacuum_lock{chars_to_uint64 ('V', 'a', 'c', 'u', 'u', 'm', 'L', 'k')};
        std::uint64_t transaction_lock{chars_to_uint64 ('T', 'r', 'n', 's', 'a', 'c', 't', 'L')};

        static constexpr auto file_offset = std::uint64_t{sizeof (header)};
        static constexpr std::uint64_t chars_to_uint64 (char const c1, char const c2, char const c3,
                                                        char const c4, char const c5, char const c6,
                                                        char const c7, char const c8) noexcept {
            return static_cast<std::uint64_t> (c1) | static_cast<std::uint64_t> (c2) << 8U |
                   static_cast<std::uint64_t> (c3) << 16U | static_cast<std::uint64_t> (c4) << 24U |
                   static_cast<std::uint64_t> (c5) << 32U | static_cast<std::uint64_t> (c6) << 40U |
                   static_cast<std::uint64_t> (c7) << 48U | static_cast<std::uint64_t> (c8) << 56U;
        }
    };

    // Assert the size, offset, and alignment of the structure and its fields to ensure file format
    // compatibility across compilers and hosts.
    PSTORE_STATIC_ASSERT (offsetof (lock_block, vacuum_lock) == 0);
    PSTORE_STATIC_ASSERT (offsetof (lock_block, transaction_lock) == 8);
    PSTORE_STATIC_ASSERT (alignof (lock_block) == 8);
    PSTORE_STATIC_ASSERT (sizeof (lock_block) == 16);

    constexpr auto leader_size = sizeof (header) + sizeof (lock_block);

    class database;

    namespace index {

#define PSTORE_INDICES                                                                             \
    X (compilation)                                                                                \
    X (debug_line_header)                                                                          \
    X (fragment)                                                                                   \
    X (name)                                                                                       \
    X (path)                                                                                       \
    X (write)

        struct header_block;
    } // namespace index

    struct trailer {
        static std::array<std::uint8_t, 8> const default_signature1;
        static std::array<std::uint8_t, 8> const default_signature2;

        bool crc_is_valid () const noexcept;
        bool signature_is_valid () const noexcept;

        static bool validate (database const & db, typed_address<trailer> pos);

        std::uint32_t get_crc () const noexcept;


#define X(a) a,
        // Note that the first enum member must have the value 0 or flush_indices() will need to
        // change.
        enum class indices : unsigned { PSTORE_INDICES last };
#undef X
        using index_records_array =
            std::array<typed_address<index::header_block>,
                       static_cast<std::underlying_type<indices>::type> (indices::last)>;

        struct body {
            std::array<std::uint8_t, 8> signature1 = default_signature1;
            std::atomic<std::uint32_t> generation{0};
            std::uint32_t unused1{0};

            std::atomic<std::uint64_t> size{0};

            std::atomic<std::uint64_t> time{0};

            typed_address<trailer> prev_generation = typed_address<trailer>::null ();

            index_records_array index_records;
            std::uint32_t unused2{0};
            std::uint32_t unused3{0};
        };


        body a;

        std::uint32_t crc = 0;
        std::uint32_t unused1 = 0;
        std::array<std::uint8_t, 8> signature2 = default_signature2;
    };

    // Assert the size, offset, and alignment of the structure and its fields to ensure file format
    // compatibility across compilers and hosts.
    PSTORE_STATIC_ASSERT (offsetof (trailer::body, signature1) == 0);
    PSTORE_STATIC_ASSERT (offsetof (trailer::body, generation) == 8);
    PSTORE_STATIC_ASSERT (offsetof (trailer::body, unused1) == 12);
    PSTORE_STATIC_ASSERT (offsetof (trailer::body, size) == 16);
    PSTORE_STATIC_ASSERT (offsetof (trailer::body, time) == 24);
    PSTORE_STATIC_ASSERT (offsetof (trailer::body, prev_generation) == 32);
    PSTORE_STATIC_ASSERT (offsetof (trailer::body, index_records) == 40);
    PSTORE_STATIC_ASSERT (offsetof (trailer::body, unused2) == 88);
    PSTORE_STATIC_ASSERT (offsetof (trailer::body, unused3) == 92);
    PSTORE_STATIC_ASSERT (alignof (trailer::body) == 8);
    PSTORE_STATIC_ASSERT (sizeof (trailer::body) == 96);

    PSTORE_STATIC_ASSERT (offsetof (trailer, a) == 0);
    PSTORE_STATIC_ASSERT (offsetof (trailer, crc) == 96);
    PSTORE_STATIC_ASSERT (offsetof (trailer, signature2) == 104);
    PSTORE_STATIC_ASSERT (alignof (trailer) == 8);
    PSTORE_STATIC_ASSERT (sizeof (trailer) == 112);

} // namespace pstore
#endif // PSTORE_CORE_FILE_HEADER_HPP