Rename struct slab_alloc to struct slab_allocator.
[barrelfish] / include / mm / mm.h
1 /**
2  * \file
3  * \brief Memory manager header
4  */
5
6 /*
7  * Copyright (c) 2008, 2011, ETH Zurich.
8  * All rights reserved.
9  *
10  * This file is distributed under the terms in the attached LICENSE file.
11  * If you do not find this file, copies can be found by writing to:
12  * ETH Zurich D-INFK, Haldeneggsteig 4, CH-8092 Zurich. Attn: Systems Group.
13  */
14
15 #ifndef BARRELFISH_MM_H
16 #define BARRELFISH_MM_H
17
18 #include <sys/cdefs.h>
19
20 #include <barrelfish/slab.h>
21 #include <mm/slot_alloc.h>
22
23 __BEGIN_DECLS
24
25 enum nodetype {
26     NodeType_Dummy,     ///< The whole region doesn't exist, but it has children
27     NodeType_Chunked,   ///< This region exists and has been split up
28     NodeType_Free,      ///< This leaf region exists and is free
29     NodeType_Allocated  ///< This leaf region exists and is allocated
30 };
31
32 /// Node in Memory manager Btree. Private.
33 // Only appears here so we can know its size
34 struct mmnode {
35     enum nodetype type;     ///< Type of this node
36     uint8_t childbits;      ///< Number of children (in bits / power of two)
37     struct capref cap;    ///< Cap to this region (invalid for Dummy regions)
38     struct mmnode *children[0];///< Child node pointers
39 };
40
41 /// Macro to statically determine size of a node, given the maxchildbits
42 #define MM_NODE_SIZE(maxchildbits) \
43     (sizeof(struct mmnode) + sizeof(struct mmnode *) * (1UL << (maxchildbits)))
44
45 /**
46  * \brief Memory manager instance data
47  *
48  * This should be opaque from the perspective of the client, but to allow
49  * them to allocate its memory, we declare it in the public header.
50  */
51 struct mm {
52     struct slab_allocator slabs;///< Slab allocator used for allocating nodes
53     slot_alloc_t slot_alloc;///< Slot allocator for allocating cspace
54     void *slot_alloc_inst;  ///< Opaque instance pointer for slot allocator
55     struct mmnode *root;    ///< Root node
56     genpaddr_t base;        ///< Base address of root node
57     enum objtype objtype;   ///< Type of capabilities stored
58     uint8_t sizebits;       ///< Size of root node (in bits)
59     uint8_t maxchildbits;   ///< Maximum number of children of every node (in bits)
60     bool delete_chunked;    ///< Delete chunked capabilities if true
61 };
62
63 void mm_debug_print(struct mmnode *mmnode, int space);
64 errval_t mm_init(struct mm *mm, enum objtype objtype, genpaddr_t base,
65                  uint8_t sizebits, uint8_t maxchildbits,
66                  slab_refill_func_t slab_refill_func,
67                  slot_alloc_t slot_alloc_func, void *slot_alloc_inst,
68                  bool delete_chunked);
69 void mm_destroy(struct mm *mm);
70 errval_t mm_add(struct mm *mm, struct capref cap, uint8_t sizebits,
71                 genpaddr_t base);
72 errval_t mm_alloc(struct mm *mm, uint8_t sizebits, struct capref *retcap,
73                   genpaddr_t *retbase);
74 errval_t mm_alloc_range(struct mm *mm, uint8_t sizebits, genpaddr_t minbase,
75                         genpaddr_t maxlimit, struct capref *retcap,
76                         genpaddr_t *retbase);
77 errval_t mm_realloc_range(struct mm *mm, uint8_t sizebits, genpaddr_t base,
78                           struct capref *retcap);
79 errval_t mm_free(struct mm *mm, struct capref cap, genpaddr_t base,
80                  uint8_t sizebits);
81
82 /// Structure to record all information about a given memory region
83 struct mem_cap {
84     struct capref cap;        ///< Cap for this region
85     uint8_t sizebits;           ///< Size of region in bits
86     genpaddr_t base;               ///< Physical base address of region
87 };
88
89 size_t mm_relinquish_all(struct mm *mm, struct mem_cap *ret, size_t retlen);
90 size_t mm_relinquish_range(struct mm *mm, genpaddr_t base, genpaddr_t limit,
91                            struct mem_cap *ret, size_t retlen);
92
93 __END_DECLS
94
95 #endif /* BARRELFISH_MM_H */