realm / realm-core / 2213

{

    m_initial_section_size = 1UL << section_shift; // page_size();

    m_free_space_state = free_space_Clean;

    m_baseline = 0;

}

{

    return m_file;

}

{

    using storage_type = std::remove_reference<decltype(Header::m_file_format[0])>::type;

    REALM_ASSERT(!util::int_cast_has_overflow<storage_type>(file_format_version));

    *streaming_header = {

        {0xFFFFFFFFFFFFFFFFULL, 0}, // top-refs

        {'T', '-', 'D', 'B'},

        {storage_type(file_format_version), 0},

        0, // reserved

        0  // flags (lsb is select bit)

    };

}

{

    // Ensure that allocation is aligned to at least 8 bytes

    static_assert(__STDCPP_DEFAULT_NEW_ALIGNMENT__ >= 8);

    total_slab_allocated.fetch_add(s, std::memory_order_relaxed);

    addr = new char[size];

    REALM_ASSERT((reinterpret_cast<size_t>(addr) & 0x7ULL) == 0);

}

{

    total_slab_allocated.fetch_sub(size, std::memory_order_relaxed);

    if (addr)

        delete[] addr;

}

{

    delete[] m_ref_translation_ptr;

    m_ref_translation_ptr.store(nullptr);

    m_translation_table_size = 0;

    set_read_only(true);

    purge_old_mappings(static_cast<uint64_t>(-1), 0);

    switch (m_attach_mode) {

        case attach_None:

            break;

        case attach_UsersBuffer:

            break;

        case attach_OwnedBuffer:

            delete[] m_data;

            break;

        case attach_SharedFile:

        case attach_UnsharedFile:

            m_data = 0;

            m_mappings.clear();

            m_youngest_live_version = 0;

            if (!keep_file_open)

                m_file.close();

            break;

        case attach_Heap:

            m_data = 0;

            break;

        default:

    }

    // Release all allocated memory - this forces us to create new

    // slabs after re-attaching thereby ensuring that the slabs are

    // placed correctly (logically) after the end of the file.

    m_slabs.clear();

    clear_freelists();

#if REALM_ENABLE_ENCRYPTION

    m_realm_file_info = nullptr;

#endif

    m_attach_mode = attach_None;

}

{

#ifdef REALM_DEBUG

    if (is_attached()) {

        // A shared group does not guarantee that all space is free

        if (m_attach_mode != attach_SharedFile) {

            // No point inchecking if free space info is invalid

            if (m_free_space_state != free_space_Invalid) {

                if (REALM_COVER_NEVER(!is_all_free())) {

            }

        }

    }

#endif

    if (is_attached())

        detach();

}

{

    CriticalSection cs(changes);

    REALM_ASSERT_EX(0 < size, size, get_file_path_for_assertions());

    REALM_ASSERT_EX((size & 0x7) == 0, size,

                    get_file_path_for_assertions()); // only allow sizes that are multiples of 8

    REALM_ASSERT_EX(is_attached(), get_file_path_for_assertions());

    // This limits the size of any array to ensure it can fit within a memory section.

    // NOTE: This limit is lower than the limit set by the encoding in node_header.hpp

    REALM_ASSERT_RELEASE_EX(size < (1 << section_shift), size, get_file_path_for_assertions());

    // If we failed to correctly record free space, new allocations cannot be

    // carried out until the free space record is reset.

    if (REALM_COVER_NEVER(m_free_space_state == free_space_Invalid))

        throw InvalidFreeSpace();

    m_free_space_state = free_space_Dirty;

    m_commit_size += size;

    // minimal allocation is sizeof(FreeListEntry)

    if (size < sizeof(FreeBlock))

        size = sizeof(FreeBlock);

    // align to multipla of 8

    if (size & 0x7)

    FreeBlock* entry = allocate_block(static_cast<int>(size));

    mark_allocated(entry);

    ref_type ref = entry->ref;

#ifdef REALM_DEBUG

    if (REALM_COVER_NEVER(m_debug_out))

        std::cerr << "Alloc ref: " << ref << " size: " << size << "\n";

#endif

    char* addr = reinterpret_cast<char*>(entry);

    REALM_ASSERT_EX(addr == translate(ref), addr, ref, get_file_path_for_assertions());

    REALM_ASSERT_EX(ref >= m_baseline, ref, m_baseline, get_file_path_for_assertions());

    return MemRef(addr, ref, *this);

}

{

    auto bb = bb_before(entry);

    if (bb->block_before_size <= 0)

        return nullptr; // no prev block, or it is in use

    return block_before(bb);

}

{

    auto bb = bb_after(entry);

    if (bb->block_after_size <= 0)

        return nullptr; // no next block, or it is in use

    return block_after(bb);

}

{

    FreeList retval;

    retval.it = m_block_map.lower_bound(size);

    if (retval.it != m_block_map.end()) {

        retval.size = retval.it->first;

    }

    else {

        retval.size = 0;

    }

    return retval;

}

{

    int needed_size = size + sizeof(BetweenBlocks) + sizeof(FreeBlock);

    while (hint.it != m_block_map.end() && hint.it->first < needed_size)

        ++hint.it;

    if (hint.it == m_block_map.end())

        hint.size = 0; // indicate "not found"

    return hint;

}

{

    FreeBlock* retval = list.it->second;

    FreeBlock* header = retval->next;

    if (header == retval)

        m_block_map.erase(list.it);

    else

        list.it->second = header;

    retval->unlink();

    return retval;

}

{

    auto _next = next;

    auto _prev = prev;

    _next->prev = prev;

    _prev->next = next;

    clear_links();

}

{

    int size = bb_before(entry)->block_after_size;

    auto it = m_block_map.find(size);

    REALM_ASSERT_EX(it != m_block_map.end(), get_file_path_for_assertions());

    auto header = it->second;

    if (header == entry) {

        header = entry->next;

        if (header == entry)

            m_block_map.erase(it);

        else

            it->second = header;

    }

    entry->unlink();

}

{

    int size = bb_before(entry)->block_after_size;

    FreeBlock* header;

    auto it = m_block_map.find(size);

    if (it != m_block_map.end()) {

        header = it->second;

        it->second = entry;

        entry->next = header;

        entry->prev = header->prev;

        entry->prev->next = entry;

        entry->next->prev = entry;

    }

    else {

        header = nullptr;

        m_block_map[size] = entry;

        entry->next = entry->prev = entry;

    }

}

{

    auto bb = bb_before(entry);

    REALM_ASSERT_EX(bb->block_after_size < 0, bb->block_after_size, get_file_path_for_assertions());

    auto alloc_size = -bb->block_after_size;

    int max_waste = sizeof(FreeBlock) + sizeof(BetweenBlocks);

    REALM_ASSERT_EX(alloc_size >= size && alloc_size <= size + max_waste, alloc_size, size,

                    get_file_path_for_assertions());

    bb->block_after_size = alloc_size;

    bb = bb_after(entry);

    REALM_ASSERT_EX(bb->block_before_size < 0, bb->block_before_size, get_file_path_for_assertions());

    REALM_ASSERT(-bb->block_before_size == alloc_size);

    bb->block_before_size = alloc_size;

}

{

    auto bb = bb_before(entry);

    REALM_ASSERT_EX(bb->block_after_size > 0, bb->block_after_size, get_file_path_for_assertions());

    auto bb2 = bb_after(entry);

    bb->block_after_size = 0 - bb->block_after_size;

    REALM_ASSERT_EX(bb2->block_before_size > 0, bb2->block_before_size, get_file_path_for_assertions());

    bb2->block_before_size = 0 - bb2->block_before_size;

}

{

    FreeList list = find(size);

    if (list.found_exact(size)) {

        return pop_freelist_entry(list);

    }

    // no exact matches.

    list = find_larger(list, size);

    FreeBlock* block;

    if (list.found_something()) {

        block = pop_freelist_entry(list);

    }

    else {

        block = grow_slab(size);

    }

    FreeBlock* remaining = break_block(block, size);

    if (remaining)

        push_freelist_entry(remaining);

    REALM_ASSERT_EX(size_from_block(block) >= size, size_from_block(block), size, get_file_path_for_assertions());

    return block;

}

{

    auto bb = reinterpret_cast<BetweenBlocks*>(slab.addr);

    bb->block_before_size = 0;

    int block_size = static_cast<int>(slab.ref_end - ref_start - 2 * sizeof(BetweenBlocks));

    bb->block_after_size = block_size;

    auto entry = block_after(bb);

    entry->clear_links();

    entry->ref = ref_start + sizeof(BetweenBlocks);

    bb = bb_after(entry);

    bb->block_before_size = block_size;

    bb->block_after_size = 0;

    return entry;

}

{

    m_block_map.clear();

}

{

    clear_freelists();

    ref_type ref_start = align_size_to_section_boundary(m_baseline.load(std::memory_order_relaxed));

    for (const auto& e : m_slabs) {

        FreeBlock* entry = slab_to_entry(e, ref_start);

        push_freelist_entry(entry);

        ref_start = align_size_to_section_boundary(e.ref_end);

    }

}

{

    int size = size_from_block(block);

    int remaining_size = size - (new_size + sizeof(BetweenBlocks));

    if (remaining_size < static_cast<int>(sizeof(FreeBlock)))

        return nullptr;

    bb_after(block)->block_before_size = remaining_size;

    bb_before(block)->block_after_size = new_size;

    auto bb_between = bb_after(block);

    bb_between->block_before_size = new_size;

    bb_between->block_after_size = remaining_size;

    FreeBlock* remaining_block = block_after(bb_between);

    remaining_block->ref = block->ref + new_size + sizeof(BetweenBlocks);

    remaining_block->clear_links();

    block->clear_links();

    return remaining_block;

}

{

    int size_first = size_from_block(first);

    int size_last = size_from_block(last);

    int new_size = size_first + size_last + sizeof(BetweenBlocks);

    bb_before(first)->block_after_size = new_size;

    bb_after(last)->block_before_size = new_size;

    return first;

}

{

    // Allocate new slab.

    // - Always allocate at least 128K. This is also the amount of

    //   memory that we allow the slab allocator to keep between

    //   transactions. Allowing it to keep a small amount between

    //   transactions makes very small transactions faster by avoiding

    //   repeated unmap/mmap system calls.

    // - When allocating, allocate as much as we already have, but

    // - Never allocate more than a full section (64MB). This policy

    //   leads to gradual allocation of larger and larger blocks until

    //   we reach allocation of entire sections.

    size += 2 * sizeof(BetweenBlocks);

    size_t new_size = minimal_alloc;

    while (new_size < uint64_t(size))

        new_size += minimal_alloc;

    size_t already_allocated = get_allocated_size();

    if (new_size < already_allocated)

        new_size = already_allocated;

    if (new_size > maximal_alloc)

        new_size = maximal_alloc;

    ref_type ref;

    if (m_slabs.empty()) {

        ref = m_baseline.load(std::memory_order_relaxed);

    }

    else {

        // Find size of memory that has been modified (through copy-on-write) in current write transaction

        ref_type curr_ref_end = to_size_t(m_slabs.back().ref_end);

        REALM_ASSERT_DEBUG_EX(curr_ref_end >= m_baseline, curr_ref_end, m_baseline, get_file_path_for_assertions());

        ref = curr_ref_end;

    }

    ref = align_size_to_section_boundary(ref);

    size_t ref_end = ref;

    if (REALM_UNLIKELY(int_add_with_overflow_detect(ref_end, new_size))) {

    REALM_ASSERT(matches_section_boundary(ref));

    std::lock_guard<std::mutex> lock(m_mapping_mutex);

    // Create new slab and add to list of slabs

    m_slabs.emplace_back(ref_end, new_size); // Throws

    const Slab& slab = m_slabs.back();

    extend_fast_mapping_with_slab(slab.addr);

    // build a single block from that entry

    return slab_to_entry(slab, ref);

}

{

    REALM_ASSERT_EX(translate(ref) == addr, translate(ref), addr, get_file_path_for_assertions());

    CriticalSection cs(changes);

    bool read_only = is_read_only(ref);

    // Get size from segment

    size_t size =

        read_only ? NodeHeader::get_byte_size_from_header(addr) : NodeHeader::get_capacity_from_header(addr);

#ifdef REALM_DEBUG

    if (REALM_COVER_NEVER(m_debug_out))

        std::cerr << "Free ref: " << ref << " size: " << size << "\n";

#endif

    if (REALM_COVER_NEVER(m_free_space_state == free_space_Invalid))

        return;

    // Mutable memory cannot be freed unless it has first been allocated, and

    // any allocation puts free space tracking into the "dirty" state.

    REALM_ASSERT_EX(read_only || m_free_space_state == free_space_Dirty, read_only, m_free_space_state,

                    free_space_Dirty, get_file_path_for_assertions());

    m_free_space_state = free_space_Dirty;

    if (read_only) {

        // Free space in read only segment is tracked separately

        try {

            REALM_ASSERT_RELEASE_EX(ref != 0, ref, get_file_path_for_assertions());

            REALM_ASSERT_RELEASE_EX(!(ref & 7), ref, get_file_path_for_assertions());

            auto next = m_free_read_only.lower_bound(ref);

            if (next != m_free_read_only.end()) {

                REALM_ASSERT_RELEASE_EX(ref + size <= next->first, ref, size, next->first, next->second,

                                        get_file_path_for_assertions());

                // See if element can be combined with next element

                if (ref + size == next->first) {

                    // if so, combine to include next element and remove that from collection

                    size += next->second;

                    next = m_free_read_only.erase(next);

                }

            }

            if (!m_free_read_only.empty() && next != m_free_read_only.begin()) {

                // There must be a previous element - see if we can merge

                auto prev = next;

                prev--;

                REALM_ASSERT_RELEASE_EX(prev->first + prev->second <= ref, ref, size, prev->first, prev->second,

                                        get_file_path_for_assertions());

                // See if element can be combined with previous element

                // We can do that just by adding the size

                if (prev->first + prev->second == ref) {

                    prev->second += size;

                    return; // Done!

                }

                m_free_read_only.emplace_hint(next, ref, size); // Throws

            }

            else {

                m_free_read_only.emplace(ref, size); // Throws

            }

        }

        catch (...) {

    }

    else {

        m_commit_size -= size;

        // fixup size to take into account the allocator's need to store a FreeBlock in a freed block

        if (size < sizeof(FreeBlock))

            size = sizeof(FreeBlock);

        // align to multipla of 8

        if (size & 0x7)

        FreeBlock* e = reinterpret_cast<FreeBlock*>(addr);

        REALM_ASSERT_RELEASE_EX(size < 2UL * 1024 * 1024 * 1024, size, get_file_path_for_assertions());

        mark_freed(e, static_cast<int>(size));

        free_block(ref, e);

    }

}

{

    // merge with surrounding blocks if possible

    block->ref = ref;

    FreeBlock* prev = get_prev_block_if_mergeable(block);

    if (prev) {

        remove_freelist_entry(prev);

        block = merge_blocks(prev, block);

    }

    FreeBlock* next = get_next_block_if_mergeable(block);

    if (next) {

        remove_freelist_entry(next);

        block = merge_blocks(block, next);

    }

    push_freelist_entry(block);

}

{

    CriticalSection cs(changes);

    if (REALM_COVER_NEVER(m_free_space_state == free_space_Invalid))

        throw InvalidFreeSpace();

    return m_free_read_only.size();

}

{

    REALM_ASSERT_DEBUG(translate(ref) == addr);

    REALM_ASSERT_EX(0 < new_size, new_size, get_file_path_for_assertions());

    REALM_ASSERT_EX((new_size & 0x7) == 0, new_size,

                    get_file_path_for_assertions()); // only allow sizes that are multiples of 8

    // Possible future enhancement: check if we can extend current space instead

    // of unconditionally allocating new space. In that case, remember to

    // check whether m_free_space_state == free_state_Invalid. Also remember to

    // fill with zero if REALM_ENABLE_ALLOC_SET_ZERO is non-zero.

    // Allocate new space

    MemRef new_mem = do_alloc(new_size); // Throws

    // Copy existing segment

    char* new_addr = new_mem.get_addr();

    realm::safe_copy_n(addr, old_size, new_addr);

    // Add old segment to freelist

    do_free(ref, addr);

#ifdef REALM_DEBUG

    if (REALM_COVER_NEVER(m_debug_out)) {

#endif // REALM_DEBUG

    return new_mem;

}

{

    {

        std::lock_guard<std::mutex> lock(m_mapping_mutex);

        if (m_mappings.size()) {

            // if we have mapped a file, m_mappings will have at least one mapping and

            // the first will be to the start of the file. Don't come here, if we're

            // just attaching a buffer. They don't have mappings.

            realm::util::encryption_read_barrier(m_mappings[0].primary_mapping, 0, sizeof(Header));

        }

    }

    const Header& header = *reinterpret_cast<const Header*>(m_data);

    int slot_selector = ((header.m_flags & SlabAlloc::flags_SelectBit) != 0 ? 1 : 0);

    int file_format_version = int(header.m_file_format[slot_selector]);

    return file_format_version;

}

{

    // LIMITATION: Only come here if we've already had a read barrier for the affected part of the file

    int slot_selector = ((header.m_flags & SlabAlloc::flags_SelectBit) != 0 ? 1 : 0);

    uint_fast64_t ref = uint_fast64_t(header.m_top_ref[slot_selector]);

    return (slot_selector == 0 && ref == 0xFFFFFFFFFFFFFFFFULL);

}

{

    if (cfg.read_only) {

    size_t expected_size = size_t(-1);

    size_t size = static_cast<size_t>(m_file.get_size());

    // It is not safe to change the size of a file on streaming form, since the footer

    // must remain available and remain at the very end of the file.

    REALM_ASSERT(!is_file_on_streaming_form());

    // check if online compaction allows us to shrink the file:

    if (top_ref) {

        // Get the expected file size by looking up logical file size stored in top array

        constexpr size_t max_top_size = (Group::s_file_size_ndx + 1) * 8 + sizeof(Header);

        size_t top_page_base = top_ref & ~(page_size() - 1);

        size_t top_offset = top_ref - top_page_base;

        size_t map_size = std::min(max_top_size + top_offset, size - top_page_base);

        File::Map<char> map_top(m_file, top_page_base, File::access_ReadOnly, map_size, 0, m_write_observer);

        realm::util::encryption_read_barrier(map_top, top_offset, max_top_size);

        auto top_header = map_top.get_addr() + top_offset;

        auto top_data = NodeHeader::get_data_from_header(top_header);

        auto w = NodeHeader::get_width_from_header(top_header);

        auto logical_size = size_t(get_direct(top_data, w, Group::s_file_size_ndx)) >> 1;

        // make sure we're page aligned, so the code below doesn't first

        // truncate the file, then expand it again

        expected_size = round_up_to_page_size(logical_size);

    }

    // Check if we can shrink the file

    if (cfg.session_initiator && expected_size < size && !cfg.read_only) {

        detach(true); // keep m_file open

        m_file.resize(expected_size);

        m_file.close();

        size = expected_size;

        return true;

    }

    // We can only safely mmap the file, if its size matches a page boundary. If not,

    // we must change the size to match before mmaping it.

    if (size != round_up_to_page_size(size)) {

        // The file size did not match a page boundary.

        // We must extend the file to a page boundary (unless already there)

        // The file must be extended to match in size prior to being mmapped,

        // as extending it after mmap has undefined behavior.

        if (cfg.session_initiator || !cfg.is_shared) {

            // We can only safely extend the file if we're the session initiator, or if

            // the file isn't shared at all. Extending the file to a page boundary is ONLY

            // done to ensure well defined behavior for memory mappings. It does not matter,

            // that the free space management isn't informed

            size = round_up_to_page_size(size);

            detach(true); // keep m_file open

            m_file.prealloc(size);

            m_file.close();

            return true;

        }

    }

    return false;

}

{

    m_cfg = cfg;

    m_write_observer = write_observer;

    // ExceptionSafety: If this function throws, it must leave the allocator in

    // the detached state.

    REALM_ASSERT_EX(!is_attached(), get_file_path_for_assertions());

    // When 'read_only' is true, this function will throw InvalidDatabase if the

    // file exists already but is empty. This can happen if another process is

    // currently creating it. Note however, that it is only legal for multiple

    // processes to access a database file concurrently if it is done via a

    // DB, and in that case 'read_only' can never be true.

    REALM_ASSERT_EX(!(cfg.is_shared && cfg.read_only), cfg.is_shared, cfg.read_only, get_file_path_for_assertions());

    // session_initiator can be set *only* if we're shared.

    REALM_ASSERT_EX(cfg.is_shared || !cfg.session_initiator, cfg.is_shared, cfg.session_initiator,

                    get_file_path_for_assertions());

    // clear_file can be set *only* if we're the first session.

    REALM_ASSERT_EX(cfg.session_initiator || !cfg.clear_file, cfg.session_initiator, cfg.clear_file,

                    get_file_path_for_assertions());

    using namespace realm::util;

    File::AccessMode access = cfg.read_only ? File::access_ReadOnly : File::access_ReadWrite;

    File::CreateMode create = cfg.read_only || cfg.no_create ? File::create_Never : File::create_Auto;

    set_read_only(cfg.read_only);

    try {

        m_file.open(path.c_str(), access, create, 0); // Throws

    }

    catch (const FileAccessError& ex) {

        auto msg = util::format_errno("Failed to open Realm file at path '%2': %1", ex.get_errno(), path);

        if (ex.code() == ErrorCodes::PermissionDenied) {

            msg += util::format(". Please use a path where your app has %1 permissions.",

                                cfg.read_only ? "read" : "read-write");

        }

        throw FileAccessError(ex.code(), msg, path, ex.get_errno());

    }

    File::CloseGuard fcg(m_file);

    auto physical_file_size = m_file.get_size();

    // Note that get_size() may (will) return a different size before and after

    // the call below to set_encryption_key.

    m_file.set_encryption_key(cfg.encryption_key);

    note_reader_start(this);

    util::ScopeExit reader_end_guard([this]() noexcept {

        note_reader_end(this);

    });

    size_t size = 0;

    // The size of a database file must not exceed what can be encoded in

    // size_t.

    if (REALM_UNLIKELY(int_cast_with_overflow_detect(m_file.get_size(), size)))

        throw InvalidDatabase("Realm file too large", path);

    if (cfg.clear_file_on_error && cfg.session_initiator) {

        if (size == 0 && physical_file_size != 0) {

            cfg.clear_file = true;

        }

        else if (size > 0) {

            try {

                read_and_validate_header(m_file, path, size, cfg.session_initiator, m_write_observer);

            }

            catch (const InvalidDatabase&) {

                cfg.clear_file = true;

            }

        }

    }

    if (cfg.clear_file) {

        m_file.resize(0);

        size = 0;

        physical_file_size = 0;

    }

    else if (cfg.encryption_key && !cfg.clear_file && size == 0 && physical_file_size != 0) {

        // The opened file holds data, but is so small it cannot have

        // been created with encryption

        throw InvalidDatabase("Attempt to open unencrypted file with encryption key", path);

    }

    if (size == 0) {

        if (REALM_UNLIKELY(cfg.read_only))

            throw InvalidDatabase("Read-only access to empty Realm file", path);

        size_t initial_size = page_size(); // m_initial_section_size;

        // exFAT does not allocate a unique id for the file until it is non-empty. It must be

        // valid at this point because File::get_unique_id() is used to distinguish

        // mappings_for_file in the encryption layer. So the prealloc() is required before

        // interacting with the encryption layer in File::write().

        // Pre-alloc initial space

        m_file.prealloc(initial_size); // Throws

        // seek() back to the start of the file in preparation for writing the header

        // This sequence of File operations is protected from races by

        // DB::m_controlmutex, so we know we are the only ones operating on the file

        m_file.seek(0);

        const char* data = reinterpret_cast<const char*>(&empty_file_header);

        m_file.write(data, sizeof empty_file_header); // Throws

        bool disable_sync = get_disable_sync_to_disk() || cfg.disable_sync;

        if (!disable_sync)

            m_file.sync(); // Throws

        size = initial_size;

    }

    ref_type top_ref = read_and_validate_header(m_file, path, size, cfg.session_initiator, m_write_observer);

    m_attach_mode = cfg.is_shared ? attach_SharedFile : attach_UnsharedFile;

    // m_data not valid at this point!

    m_baseline = 0;

    // make sure that any call to begin_read cause any slab to be placed in free

    // lists correctly

    m_free_space_state = free_space_Invalid;

    // Ensure clean up, if we need to back out:

    DetachGuard dg(*this);

    reset_free_space_tracking();

    update_reader_view(size);

    REALM_ASSERT(m_mappings.size());

    m_data = m_mappings[0].primary_mapping.get_addr();

    realm::util::encryption_read_barrier(m_mappings[0].primary_mapping, 0, sizeof(Header));

    dg.release();  // Do not detach

    fcg.release(); // Do not close

#if REALM_ENABLE_ENCRYPTION

    m_realm_file_info = util::get_file_info_for_file(m_file);

#endif

    return top_ref;

}

{

    auto header = reinterpret_cast<const Header*>(m_data);

    if (!is_file_on_streaming_form(*header))

        return;

    // Make sure the database is not on streaming format. If we did not do this,

    // a later commit would have to do it. That would require coordination with

    // anybody concurrently joining the session, so it seems easier to do it at

    // session initialization, even if it means writing the database during open.

    {

        File::Map<Header> writable_map(m_file, File::access_ReadWrite, sizeof(Header)); // Throws