我试图弄清楚如何在操作系统中以最低级别分配内存。据我所知，操作系统只是在对可用内存和不可用内存进行记账，而C编程语言将在最低级别进行分配。
因此，第一个示例是我作为一个简单的内存分配系统想到的，然后从以下资源中获取了一个示例：https://github.com/levex/osdev。
示例1：
struct heap_elements {
int start_address;
int end_address;
int size;
int reservation;
};
struct heap_elements heap[25];
// Write len copies of val into dest.
void memset(int *dest, int val, int len)
{
int *temp = (int *)dest;
for ( ; len != 0; len--) *temp++ = val;
}
/*
* This function will take a source and destination and copy n amount
* - of bytes from the source to the destination address.
*/
void memory_copy(unsigned char *source, unsigned char *destination, int bytes) {
for (int i = 0; i < bytes; i++) {
*(destination + i) = *(source + i);
}
}
int find_memory_hole(int size) {
for (int i = 0; i < total_elements; i++) {
if (heap[i].reservation == 0) {
if (heap[i].size >= size || heap[i].size == 0) {
return i;
}
}
}
return -1;
}
int * malloc(int size) {
int hole = find_memory_hole(size);
if (hole != -1) {
if (heap[hole].start_address == 0) {
heap[hole].start_address = ending_address;
ending_address += size;
heap[hole].end_address = ending_address;
heap[hole].size = size;
heap[hole].reservation = 1;
kprintf("Starting address: %d\n", heap[hole].start_address);
kprintf("Ending address: %d\n", heap[hole].end_address);
} else {
heap[hole].size = size;
heap[hole].reservation = 1;
}
memset((int*)heap[hole].start_address, 0, size);
return (int*)heap[hole].start_address;
} else {
kprintf("FREE SOME MEMORY~!\n");
kprintf("WE NEED ROOM IN HERE~!\n");
return 0;
}
}
void heap_install() {
total_elements = 25;
starting_address = 0x100000; // 1 - MB
ending_address = 0x100000; // 1 - MB
max_memory_address = 0xEEE00000; // 4 - GB
for (int i = 0; i < total_elements; i++) {
heap[i].start_address = 0;
heap[i].end_address = 0;
heap[i].size = 0;
heap[i].reservation = 0;
}
return;
}
void free(void * pointer) {
int memory_found = 0;
kprintf("Address %d\n", &pointer);
int memory_address = &pointer;
for (int i = 0; i < total_elements; i++) {
if (heap[i].start_address == memory_address) {
heap[i].size = 0;
heap[i].reservation = 0;
memory_found = 1;
break;
}
}
if (memory_found == 0)
kprintf("Memory could not bee free'd (NOT FOUND).\n");
return;
}
示例2：
void mm_init(unsigned kernel_end)
{
kprintf("The kernel end is: %d\n", kernel_end);
last_alloc = kernel_end + 0x1000; // Set our starting point.
heap_begin = last_alloc;
heap_end = 0x5B8D80; // Set the bar to 6 MB
memset((char *)heap_begin, 0, heap_end - heap_begin);
}
void mm_print_out()
{
kprintf("Memory used: %d bytes\n", memory_used);
kprintf("Memory free: %d bytes\n", heap_end - heap_begin - memory_used);
kprintf("Heap size: %d bytes\n", heap_end - heap_begin);
kprintf("Heap start: 0x%x\n", heap_begin);
kprintf("Heap end: 0x%x\n", heap_end);
}
void free(void *mem)
{
alloc_t *alloc = (mem - sizeof(alloc_t));
memory_used -= alloc->size + sizeof(alloc_t);
alloc->status = 0;
}
char* malloc(unsigned size)
{
if(!size) return 0;
/* Loop through blocks and find a block sized the same or bigger */
unsigned char *mem = (unsigned char *)heap_begin;
while((unsigned)mem < last_alloc)
{
alloc_t *a = (alloc_t *)mem;
/* If the alloc has no size, we have reaced the end of allocation */
if(!a->size)
goto nalloc;
/* If the alloc has a status of 1 (allocated), then add its size
* and the sizeof alloc_t to the memory and continue looking.
*/
if(a->status) {
mem += a->size;
mem += sizeof(alloc_t);
mem += 4;
continue;
}
/* If the is not allocated, and its size is bigger or equal to the
* requested size, then adjust its size, set status and return the location.
*/
if(a->size >= size)
{
/* Set to allocated */
a->status = 1;
memset(mem + sizeof(alloc_t), 0, size);
memory_used += size + sizeof(alloc_t);
return (char *)(mem + sizeof(alloc_t));
}
/* If it isn't allocated, but the size is not good, then
* add its size and the sizeof alloc_t to the pointer and
* continue;
*/
mem += a->size;
mem += sizeof(alloc_t);
mem += 4;
}
nalloc:;
if(last_alloc+size+sizeof(alloc_t) >= heap_end)
{
panic("From Memory.c", "Something", 0);
}
alloc_t *alloc = (alloc_t *)last_alloc;
alloc->status = 1;
alloc->size = size;
last_alloc += size;
last_alloc += sizeof(alloc_t);
last_alloc += 4;
memory_used += size + 4 + sizeof(alloc_t);
memset((char *)((unsigned)alloc + sizeof(alloc_t)), 0, size);
return (char *)((unsigned)alloc + sizeof(alloc_t));
}
从两个示例中，我都希望从malloc（）分配的内存与在其分配的位置具有相同的起始地址，如果有意义的话？如果我知道内核的末尾是0x9000标记，那么我想开始以1 MB标记分配内存。是的，我知道我的内核在内存中的位置很奇怪，而不是常规的，但我知道超过1 MB标记后内存是可用的。
所以，如果我知道以下内容：
kernel_end = 0x9000;
heap_starts = 0x100000;
heap_ends = 0x5B8D80;
我希望这样：
char * ptr = malloc(5)
printf("The memory address for this pointer is at: %d\n", &ptr);
将在0x100000内存地址附近，但不是。这是一些完全不同的地方，这也是为什么我认为我不是在物理上告诉char指针在内存中的位置，而是C语言将它放在不同的地方的原因。我无法弄清楚我在做什么错，理解这一点应该不难。另外，我查看了OSDev Wiki，但未发现任何内容。
答案 0 :(得分：5)
我试图弄清楚如何在最低级别分配内存 在操作系统中。据我所知， 系统只是对可用内存进行记录 并且不可用，它将是C编程语言 最低级别的分配。
操作系统肯定会对可用内存和不可用内存进行簿记，但是用这些术语将其大大简化了，我怀疑您对“内存”在这里的含义和最合适的含义有所不同。
操作系统的虚拟内存管理子系统管理如何将物理内存和其他存储资源（例如基于磁盘的交换空间）映射到每个进程的虚拟地址空间，包括多少以及进程的虚拟地址空间映射到可用内存。它可以处理增加或减少进程的可用虚拟内存的请求，也可以用于创建内存映射的显式请求，例如基于普通文件的内存映射。
就为用户空间程序中的malloc()调用提供服务而言，您或多或少是正确的。程序通常从操作系统中以较大的块获取内存，malloc()，free()和朋友可以分担和管理。通常，只有当进程填满了已经可用的内存，并且需要向内核请求更多信息时，这些细节才涉及内核。
但是最低级别肯定在内核中。 C库的内存管理功能只能与OS分配给进程的内存一起使用。
从两个示例中，我都希望从malloc（）分配内存 如果我在哪里分配了相同的起始地址，如果 那讲得通？如果我知道内核的末尾是0x9000 标记，而我想从1 MB标记开始分配内存。是的，我 知道我的内核在内存中的位置很奇怪，而不是常规的，但是我 知道内存已超过1 MB标记。
内核的内存视图不同于用户空间进程。每个进程都在其自己的虚拟地址空间中运行，无法查看其使用的物理地址。
答案 1 :(得分：1)
我试图弄清楚如何在操作系统的最低级别分配内存。
您的问题是您没有在看操作系统如何分配内存。您正在查看应用程序级别的内存分配。
对于进程，操作系统仅在PAGES中分配内存。进程通过调用将更多页面映射到进程地址（即，使更多页面有效）的系统服务来获取更多内存。
因为应用程序通常需要小于页面的内存分配（对于诸如字符串之类的东西），所以经常使用堆管理功能。 malloc和free很少（如果有的话）是操作系统服务。这些简单的函数可以以小于页面的增量分配内存。
通常，对malloc的调用会导致该函数尝试查找足够大的内存块以返回给调用者。如果没有这样的块，则malloc将调用操作系统服务以将页面映射到地址空间，以增加堆中的可用内存量，以便它可以返回足够大的内存块。