xv6-cs450/kalloc.c

130 lines
2.7 KiB
C
Raw Normal View History

2006-09-06 19:50:20 +02:00
// 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.
2006-06-12 17:22:12 +02:00
#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;
2006-06-12 17:22:12 +02:00
struct run {
struct run *next;
int len; // bytes
};
struct run *freelist;
2006-09-06 19:50:20 +02:00
// 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.
2006-06-12 17:22:12 +02:00
void
2006-07-16 18:05:37 +02:00
kinit(void)
2006-06-12 17:22:12 +02:00
{
extern int end;
uint mem;
2006-06-12 17:22:12 +02:00
char *start;
2006-09-06 19:27:19 +02:00
initlock(&kalloc_lock, "kalloc");
2006-09-06 19:27:19 +02:00
start = (char*) &end;
start = (char*) (((uint)start + PAGE) & ~(PAGE-1));
2006-09-08 16:36:44 +02:00
mem = 256; // assume computer has 256 pages of RAM
2006-06-12 17:22:12 +02:00
cprintf("mem = %d\n", mem * PAGE);
kfree(start, mem * PAGE);
}
2007-08-10 18:37:27 +02:00
// Free the len bytes of memory pointed at by v,
2006-09-07 16:12:30 +02:00
// which normally should have been returned by a
2007-08-10 18:37:27 +02:00
// call to kalloc(len). (The exception is when
2006-09-07 16:12:30 +02:00
// initializing the allocator; see kinit above.)
2006-06-12 17:22:12 +02:00
void
2007-08-10 18:37:27 +02:00
kfree(char *v, int len)
2006-06-12 17:22:12 +02:00
{
2007-08-10 19:02:36 +02:00
struct run **rr, *p, *pend;
2006-06-12 17:22:12 +02:00
if(len % PAGE)
panic("kfree");
2006-09-06 20:06:04 +02:00
// Fill with junk to catch dangling refs.
2007-08-10 18:37:27 +02:00
memset(v, 1, len);
acquire(&kalloc_lock);
2007-08-10 19:02:36 +02:00
p = (struct run*)v;
pend = (struct run*)(v + len);
2006-06-12 17:22:12 +02:00
rr = &freelist;
while(*rr){
2006-09-06 19:27:19 +02:00
struct run *rend = (struct run*) ((char*)(*rr) + (*rr)->len);
2006-06-12 17:22:12 +02:00
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;
2006-06-12 17:22:12 +02:00
}
if(pend < *rr){
p->len = len;
p->next = *rr;
*rr = p;
goto out;
2006-06-12 17:22:12 +02:00
}
if(p == rend){
(*rr)->len += len;
if((*rr)->next && (*rr)->next == pend){
(*rr)->len += (*rr)->next->len;
(*rr)->next = (*rr)->next->next;
}
goto out;
2006-06-12 17:22:12 +02:00
}
rr = &((*rr)->next);
}
p->len = len;
p->next = 0;
*rr = p;
out:
release(&kalloc_lock);
2006-06-12 17:22:12 +02:00
}
2006-09-06 19:50:20 +02:00
// Allocate n bytes of physical memory.
// Returns a kernel-segment pointer.
// Returns 0 if the memory cannot be allocated.
2006-07-16 18:05:37 +02:00
char*
2006-06-12 17:22:12 +02:00
kalloc(int n)
{
2007-08-10 19:02:36 +02:00
char *p;
struct run *r, **rr;
2006-06-12 17:22:12 +02:00
if(n % PAGE)
panic("kalloc");
acquire(&kalloc_lock);
2006-06-12 17:22:12 +02:00
rr = &freelist;
while(*rr){
2007-08-10 19:02:36 +02:00
r = *rr;
2006-06-12 17:22:12 +02:00
if(r->len == n){
*rr = r->next;
release(&kalloc_lock);
2006-09-06 19:27:19 +02:00
return (char*) r;
2006-06-12 17:22:12 +02:00
}
if(r->len > n){
r->len -= n;
2007-08-10 19:02:36 +02:00
p = (char*)r + r->len;
release(&kalloc_lock);
2006-06-12 17:22:12 +02:00
return p;
}
rr = &(*rr)->next;
}
release(&kalloc_lock);
2006-08-30 20:55:06 +02:00
cprintf("kalloc: out of memory\n");
2006-06-12 17:22:12 +02:00
return 0;
}