summaryrefslogtreecommitdiff
path: root/Kernel/Memory/RegionTree.h
blob: 93f6047bfbb73f5be60a72f4aa0bc7b1dfbf1126 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
/*
 * Copyright (c) 2022, Andreas Kling <kling@serenityos.org>
 *
 * SPDX-License-Identifier: BSD-2-Clause
 */

#pragma once

#include <AK/Error.h>
#include <AK/IntrusiveRedBlackTree.h>
#include <Kernel/Locking/Spinlock.h>
#include <Kernel/Memory/Region.h>
#include <Kernel/Memory/VirtualRange.h>
#include <Kernel/VirtualAddress.h>

namespace Kernel::Memory {

enum class RandomizeVirtualAddress {
    No,
    Yes,
};

// RegionTree represents a virtual address space.
// It is used by MemoryManager for kernel VM and by AddressSpace for user VM.
// Regions are stored in an intrusive data structure and there are no allocations when interacting with it.
class RegionTree {
    AK_MAKE_NONCOPYABLE(RegionTree);
    AK_MAKE_NONMOVABLE(RegionTree);

public:
    explicit RegionTree(VirtualRange total_range)
        : m_total_range(total_range)
    {
    }

    ~RegionTree();

    auto& regions() { return m_regions; }
    auto const& regions() const { return m_regions; }

    VirtualRange total_range() const { return m_total_range; }

    ErrorOr<void> place_anywhere(Region&, RandomizeVirtualAddress, size_t size, size_t alignment = PAGE_SIZE);
    ErrorOr<void> place_specifically(Region&, VirtualRange const&);

    void delete_all_regions_assuming_they_are_unmapped();

    // FIXME: Access the region tree through a SpinlockProtected or similar.
    RecursiveSpinlock& get_lock() const { return m_lock; }

    bool remove(Region&);

    Region* find_region_containing(VirtualAddress);
    Region* find_region_containing(VirtualRange);

private:
    ErrorOr<VirtualRange> allocate_range_anywhere(size_t size, size_t alignment = PAGE_SIZE);
    ErrorOr<VirtualRange> allocate_range_specific(VirtualAddress base, size_t size);
    ErrorOr<VirtualRange> allocate_range_randomized(size_t size, size_t alignment = PAGE_SIZE);

    RecursiveSpinlock mutable m_lock;

    IntrusiveRedBlackTree<&Region::m_tree_node> m_regions;
    VirtualRange const m_total_range;
};

}