303 lines
11 KiB
C
303 lines
11 KiB
C
/*
|
|
The Clear BSD License
|
|
|
|
Copyright (c) 2023 Max Wash
|
|
All rights reserved.
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted (subject to the limitations in the disclaimer
|
|
below) provided that the following conditions are met:
|
|
|
|
- Redistributions of source code must retain the above copyright notice,
|
|
this list of conditions and the following disclaimer.
|
|
|
|
- Redistributions in binary form must reproduce the above copyright
|
|
notice, this list of conditions and the following disclaimer in the
|
|
documentation and/or other materials provided with the distribution.
|
|
|
|
- Neither the name of the copyright holder nor the names of its
|
|
contributors may be used to endorse or promote products derived from this
|
|
software without specific prior written permission.
|
|
*/
|
|
#ifndef SOCKS_MEMBLOCK_H_
|
|
#define SOCKS_MEMBLOCK_H_
|
|
|
|
#include <stddef.h>
|
|
#include <limits.h>
|
|
#include <socks/types.h>
|
|
|
|
#define MEMBLOCK_INIT_MEMORY_REGION_COUNT 128
|
|
#define MEMBLOCK_INIT_RESERVED_REGION_COUNT 128
|
|
|
|
#define __for_each_mem_range(i, type_a, type_b, p_start, p_end) \
|
|
for ((i)->__idx = 0, __next_memory_region(i, type_a, type_b, p_start, p_end); \
|
|
(i)->__idx != ULLONG_MAX; \
|
|
__next_memory_region(i, type_a, type_b, p_start, p_end))
|
|
|
|
/* iterate through all memory regions known to memblock.
|
|
|
|
this consists of all regions that have been registered
|
|
with memblock using memblock_add().
|
|
|
|
this iteration can be optionally constrained to a given region.
|
|
|
|
@param i the iterator. this should be a pointer of type memblock_iter_t.
|
|
for each iteration, this structure will be filled with details about
|
|
the current memory region.
|
|
@param p_start the lower bound of the memory region to iterate through.
|
|
if you don't want to use a lower bound, pass 0.
|
|
@param p_end the upper bound of the memory region to iterate through.
|
|
if you don't want to use an upper bound, pass UINTPTR_MAX.
|
|
|
|
EXAMPLE: to iterate through all memory regions (with no bounds):
|
|
|
|
memblock_iter_t it;
|
|
for_each_mem_region (&it, 0x0, UINTPTR_MAX) { ... }
|
|
|
|
|
|
EXAMPLE: to iterate through all memory regions between physical
|
|
addresses 0x40000 and 0x80000:
|
|
|
|
memblock_iter_t it;
|
|
for_each_mem_region (&it, 0x40000, 0x80000) { ... }
|
|
*/
|
|
#define for_each_mem_range(i, p_start, p_end) \
|
|
__for_each_mem_range(i, &memblock.memory, NULL, p_start, p_end)
|
|
|
|
/* iterate through all memory regions reserved using memblock.
|
|
|
|
this consists of all regions that have been registered
|
|
with memblock using memblock_reserve().
|
|
|
|
this iteration can be optionally constrained to a given region.
|
|
|
|
@param i the iterator. this should be a pointer of type memblock_iter_t.
|
|
for each iteration, this structure will be filled with details about
|
|
the current memory region.
|
|
@param p_start the lower bound of the memory region to iterate through.
|
|
if you don't want to use a lower bound, pass 0.
|
|
@param p_end the upper bound of the memory region to iterate through.
|
|
if you don't want to use an upper bound, pass UINTPTR_MAX.
|
|
|
|
EXAMPLE: to iterate through all reserved memory regions (with no bounds):
|
|
|
|
memblock_iter_t it;
|
|
for_each_reserved_mem_region (&it, 0x0, UINTPTR_MAX) { ... }
|
|
|
|
|
|
EXAMPLE: to iterate through all reserved memory regions between physical
|
|
addresses 0x40000 and 0x80000:
|
|
|
|
memblock_iter_t it;
|
|
for_each_reserved_mem_region (&it, 0x40000, 0x80000) { ... }
|
|
*/
|
|
#define for_each_reserved_mem_range(i, p_start, p_end) \
|
|
__for_each_mem_range(i, &memblock.reserved, NULL, p_start, p_end)
|
|
|
|
/* iterate through all memory regions known by memblock to be free.
|
|
|
|
this consists of all regions BETWEEN those regions that have been
|
|
registered using memblock_reserve(), bounded within the memory
|
|
regions added using memblock_add().
|
|
|
|
this iteration can be optionally constrained to a given region.
|
|
|
|
@param i the iterator. this should be a pointer of type memblock_iter_t.
|
|
for each iteration, this structure will be filled with details about
|
|
the current memory region.
|
|
@param p_start the lower bound of the memory region to iterate through.
|
|
if you don't want to use a lower bound, pass 0.
|
|
@param p_end the upper bound of the memory region to iterate through.
|
|
if you don't want to use an upper bound, pass UINTPTR_MAX.
|
|
|
|
EXAMPLE: if you have added the following memory regions to
|
|
memblock using memblock_add():
|
|
|
|
- 0x00000 -> 0x05fff
|
|
- 0x08000 -> 0x1ffff
|
|
|
|
...and you have reserved the following memory regions using
|
|
memblock_reserve():
|
|
|
|
- 0x01000 -> 0x04fff
|
|
- 0x09000 -> 0x0ffff
|
|
|
|
the following call:
|
|
|
|
memblock_iter_t it;
|
|
for_each_free_mem_range (&it, 0x0, UINTPTR_MAX) { ... }
|
|
|
|
would iterate through the following sequence of free memory ranges:
|
|
|
|
- 0x00000 -> 0x00fff
|
|
- 0x05000 -> 0x05fff
|
|
- 0x08000 -> 0x08fff
|
|
- 0x10000 -> 0x1ffff
|
|
*/
|
|
#define for_each_free_mem_range(i, p_start, p_end) \
|
|
__for_each_mem_range(i, &memblock.memory, &memblock.reserved, p_start, p_end)
|
|
|
|
typedef uint64_t memblock_index_t;
|
|
|
|
typedef enum memblock_region_status {
|
|
/* Used in memblock.memory regions, indicates that the memory region exists */
|
|
MEMBLOCK_MEMORY = 0,
|
|
/* Used in memblock.reserved regions, indicates that the memory region was reserved
|
|
* by a call to memblock_alloc() */
|
|
MEMBLOCK_ALLOC,
|
|
/* Used in memblock.reserved regions, indicates that the memory region was reserved
|
|
* by a call to memblock_reserve() */
|
|
MEMBLOCK_RESERVED,
|
|
} memblock_region_status_t;
|
|
|
|
typedef struct memblock_region {
|
|
/* the status of the memory region (free, reserved, allocated, etc) */
|
|
memblock_region_status_t status;
|
|
/* the address of the first byte that makes up the region */
|
|
phys_addr_t base;
|
|
/* the address of the last byte that makes up the region */
|
|
phys_addr_t limit;
|
|
} memblock_region_t;
|
|
|
|
/* buffer of memblock regions, all of which are the same type
|
|
(memory, reserved, etc) */
|
|
typedef struct memblock_type {
|
|
struct memblock_region *regions;
|
|
unsigned int count;
|
|
unsigned int max;
|
|
const char *name;
|
|
} memblock_type_t;
|
|
|
|
typedef struct memblock {
|
|
/* bounds of the memory region that can be used by memblock_alloc()
|
|
both of these are virtual addresses */
|
|
uintptr_t m_alloc_start, m_alloc_end;
|
|
/* memblock assumes that all memory in the alloc zone is contiguously mapped
|
|
(if paging is enabled). m_voffset is the offset that needs to be added to
|
|
a given physical address to get the corresponding virtual address */
|
|
uintptr_t m_voffset;
|
|
|
|
struct memblock_type memory;
|
|
struct memblock_type reserved;
|
|
} memblock_t;
|
|
|
|
typedef struct memblock_iter {
|
|
memblock_index_t __idx;
|
|
phys_addr_t it_base;
|
|
phys_addr_t it_limit;
|
|
memblock_region_status_t it_status;
|
|
} memblock_iter_t;
|
|
|
|
/* global memblock state. */
|
|
extern memblock_t memblock;
|
|
|
|
extern int __next_mem_range(memblock_iter_t *it);
|
|
|
|
/* initialise the global memblock state.
|
|
this function must be called before any other memblock functions can be used.
|
|
|
|
this function sets the bounds of the heap area. memory allocation requests
|
|
using memblock_alloc() will be constrained to this zone.
|
|
|
|
memblock assumes that all physical memory in the system is mapped to
|
|
an area in virtual memory, such that converting a physical address to
|
|
a valid virtual address can be done by simply applying an offset.
|
|
|
|
@param alloc_start the virtual address of the start of the heap area.
|
|
@param alloc_end the virtual address of the end of the heap area.
|
|
@param voffset the offset between the physical address of a given page and
|
|
its corresponding virtual address.
|
|
*/
|
|
extern int memblock_init(uintptr_t alloc_start, uintptr_t alloc_end, uintptr_t voffset);
|
|
|
|
/* add a region of memory to memblock.
|
|
|
|
this function is used to define regions of memory that are accessible, but
|
|
says nothing about the STATE of the given memory.
|
|
|
|
all memory is free by default. once a region of memory is added,
|
|
memblock_reserve() can be used to mark the memory as reserved.
|
|
|
|
@param base the physical address of the start of the memory region to add.
|
|
@oaram size the size of the memory region to add in bytes.
|
|
*/
|
|
extern int memblock_add(phys_addr_t base, size_t size);
|
|
/* mark a region of memory as reserved.
|
|
|
|
this function can only operate on regions of memory that have been previously
|
|
registered with memblock using memblock_add().
|
|
|
|
reserved memory will not be used by memblock_alloc(), and will remain
|
|
reserved when the vm_page memory map is initialised.
|
|
|
|
@param base the physical address of the start of the memory region to reserve.
|
|
@oaram size the size of the memory region to reserve in bytes.
|
|
*/
|
|
extern int memblock_reserve(phys_addr_t base, size_t size);
|
|
|
|
/* allocate a block of memory, returning a virtual address.
|
|
|
|
this function selects the first available region of memory that satisfies
|
|
the requested allocation size, marks `size` bytes of this region as reserved,
|
|
and returns the virtual address of the region.
|
|
|
|
when looking for a suitable region of memory, this function searches the
|
|
intersection of the following memory zones:
|
|
- the regions of memory added with memblock_alloc().
|
|
- the region of memory specified as the heap bounds during the call
|
|
to memblock_init().
|
|
and excludes the following regions:
|
|
- the regions of memory marked as reserved by memblock_reserve() and
|
|
previous calls to memblock_alloc()
|
|
|
|
@param size the size of the buffer to allocate in bytes.
|
|
*/
|
|
extern void *memblock_alloc(size_t size);
|
|
|
|
/* allocate a block of memory, returning a physical address.
|
|
|
|
this function selects the first available region of memory that satisfies
|
|
the requested allocation size, marks `size` bytes of this region as reserved,
|
|
and returns the virtual address of the region.
|
|
|
|
when looking for a suitable region of memory, this function searches the
|
|
intersection of the following memory zones:
|
|
- the regions of memory added with memblock_alloc().
|
|
- the region of memory specified as the heap bounds during the call
|
|
to memblock_init().
|
|
and excludes the following regions:
|
|
- the regions of memory marked as reserved by memblock_reserve() and
|
|
previous calls to memblock_alloc()
|
|
|
|
@param size the size of the buffer to allocate in bytes.
|
|
*/
|
|
extern phys_addr_t memblock_alloc_phys(size_t size);
|
|
|
|
/* free a block of memory using its virtual address.
|
|
|
|
due to limitations in memblock (as it is meant to be a simple,
|
|
early-boot allocator), you must specify the size of the memory
|
|
region you intend to free.
|
|
|
|
@param addr the virtual address of the region to free.
|
|
@param size the size of the region to free in bytes.
|
|
*/
|
|
extern int memblock_free(void *addr, size_t size);
|
|
|
|
/* free a block of memory using its physical address.
|
|
|
|
due to limitations in memblock (as it is meant to be a simple,
|
|
early-boot allocator), you must specify the size of the memory
|
|
region you intend to free.
|
|
|
|
@param addr the physical address of the region to free.
|
|
@param size the size of the region to free in bytes.
|
|
*/
|
|
extern int memblock_free_phys(phys_addr_t addr, size_t size);
|
|
|
|
extern void __next_memory_region(memblock_iter_t *it, \
|
|
memblock_type_t *type_a, memblock_type_t *type_b,
|
|
phys_addr_t start, phys_addr_t end);
|
|
|
|
#endif
|