129 lines
2.7 KiB
C
129 lines
2.7 KiB
C
// Physical memory allocator, intended to allocate
|
|
// memory for user processes. Allocates in 4096-byte "pages".
|
|
// Free list is kept sorted and combines adjacent pages into
|
|
// long runs, to make it easier to allocate big segments.
|
|
// One reason the page size is 4k is that the x86 segment size
|
|
// granularity is 4k.
|
|
|
|
#include "param.h"
|
|
#include "types.h"
|
|
#include "defs.h"
|
|
#include "param.h"
|
|
#include "mmu.h"
|
|
#include "proc.h"
|
|
#include "spinlock.h"
|
|
|
|
struct spinlock kalloc_lock;
|
|
|
|
struct run {
|
|
struct run *next;
|
|
int len; // bytes
|
|
};
|
|
struct run *freelist;
|
|
|
|
// Initialize free list of physical pages.
|
|
// This code cheats by just considering one megabyte of
|
|
// pages after _end. Real systems would determine the
|
|
// amount of memory available in the system and use it all.
|
|
void
|
|
kinit(void)
|
|
{
|
|
extern int end;
|
|
uint mem;
|
|
char *start;
|
|
|
|
initlock(&kalloc_lock, "kalloc");
|
|
start = (char*) &end;
|
|
start = (char*) (((uint)start + PAGE) & ~(PAGE-1));
|
|
mem = 256; // assume computer has 256 pages of RAM
|
|
cprintf("mem = %d\n", mem * PAGE);
|
|
kfree(start, mem * PAGE);
|
|
}
|
|
|
|
// Free the len bytes of memory pointed at by v,
|
|
// which normally should have been returned by a
|
|
// call to kalloc(len). (The exception is when
|
|
// initializing the allocator; see kinit above.)
|
|
void
|
|
kfree(char *v, int len)
|
|
{
|
|
struct run **rr, *p, *pend;
|
|
|
|
if(len % PAGE)
|
|
panic("kfree");
|
|
|
|
// Fill with junk to catch dangling refs.
|
|
memset(v, 1, len);
|
|
|
|
acquire(&kalloc_lock);
|
|
p = (struct run*)v;
|
|
pend = (struct run*)(v + len);
|
|
rr = &freelist;
|
|
while(*rr){
|
|
struct run *rend = (struct run*) ((char*)(*rr) + (*rr)->len);
|
|
if(p >= *rr && p < rend)
|
|
panic("freeing free page");
|
|
if(pend == *rr){
|
|
p->len = len + (*rr)->len;
|
|
p->next = (*rr)->next;
|
|
*rr = p;
|
|
goto out;
|
|
}
|
|
if(pend < *rr){
|
|
p->len = len;
|
|
p->next = *rr;
|
|
*rr = p;
|
|
goto out;
|
|
}
|
|
if(p == rend){
|
|
(*rr)->len += len;
|
|
if((*rr)->next && (*rr)->next == pend){
|
|
(*rr)->len += (*rr)->next->len;
|
|
(*rr)->next = (*rr)->next->next;
|
|
}
|
|
goto out;
|
|
}
|
|
rr = &((*rr)->next);
|
|
}
|
|
p->len = len;
|
|
p->next = 0;
|
|
*rr = p;
|
|
|
|
out:
|
|
release(&kalloc_lock);
|
|
}
|
|
|
|
// Allocate n bytes of physical memory.
|
|
// Returns a kernel-segment pointer.
|
|
// Returns 0 if the memory cannot be allocated.
|
|
char*
|
|
kalloc(int n)
|
|
{
|
|
char *p;
|
|
struct run *r, **rr;
|
|
|
|
if(n % PAGE)
|
|
panic("kalloc");
|
|
|
|
acquire(&kalloc_lock);
|
|
|
|
rr = &freelist;
|
|
while(*rr){
|
|
r = *rr;
|
|
if(r->len == n){
|
|
*rr = r->next;
|
|
release(&kalloc_lock);
|
|
return (char*) r;
|
|
}
|
|
if(r->len > n){
|
|
r->len -= n;
|
|
p = (char*)r + r->len;
|
|
release(&kalloc_lock);
|
|
return p;
|
|
}
|
|
rr = &(*rr)->next;
|
|
}
|
|
release(&kalloc_lock);
|
|
cprintf("kalloc: out of memory\n");
|
|
return 0;
|
|
}
|