xv6-65oo2/kalloc.c

115 lines
2.6 KiB
C
Raw Normal View History

2006-09-06 17:50:20 +00: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 15:22:12 +00:00
#include "types.h"
#include "defs.h"
#include "param.h"
#include "spinlock.h"
2006-06-12 15:22:12 +00:00
struct run {
struct run *next;
int len; // bytes
};
struct {
struct spinlock lock;
struct run *freelist;
} kmem;
2006-06-12 15:22:12 +00:00
2006-09-06 17:50:20 +00:00
// Initialize free list of physical pages.
// This code cheats by just considering one megabyte of
2009-07-12 02:26:01 +00:00
// pages after end. Real systems would determine the
2006-09-06 17:50:20 +00:00
// amount of memory available in the system and use it all.
2006-06-12 15:22:12 +00:00
void
2006-07-16 16:05:37 +00:00
kinit(void)
2006-06-12 15:22:12 +00:00
{
2009-07-12 02:26:01 +00:00
extern char end[];
uint len;
char *p;
2006-09-06 17:27:19 +00:00
initlock(&kmem.lock, "kmem");
2009-07-12 02:26:01 +00:00
p = (char*)(((uint)end + PAGE) & ~(PAGE-1));
len = 256*PAGE; // assume computer has 256 pages of RAM, 1 MB
cprintf("mem = %d\n", len);
kfree(p, len);
2006-06-12 15:22:12 +00:00
}
2007-08-10 16:37:27 +00:00
// Free the len bytes of memory pointed at by v,
2006-09-07 14:12:30 +00:00
// which normally should have been returned by a
2007-08-10 16:37:27 +00:00
// call to kalloc(len). (The exception is when
2006-09-07 14:12:30 +00:00
// initializing the allocator; see kinit above.)
2006-06-12 15:22:12 +00:00
void
2007-08-10 16:37:27 +00:00
kfree(char *v, int len)
2006-06-12 15:22:12 +00:00
{
2007-08-14 19:05:48 +00:00
struct run *r, *rend, **rp, *p, *pend;
2006-06-12 15:22:12 +00:00
2007-08-14 19:05:48 +00:00
if(len <= 0 || len % PAGE)
2006-06-12 15:22:12 +00:00
panic("kfree");
2006-09-06 18:06:04 +00:00
// Fill with junk to catch dangling refs.
2007-08-10 16:37:27 +00:00
memset(v, 1, len);
acquire(&kmem.lock);
2007-08-10 17:02:36 +00:00
p = (struct run*)v;
pend = (struct run*)(v + len);
for(rp=&kmem.freelist; (r=*rp) != 0 && r <= pend; rp=&r->next){
2007-08-14 19:05:48 +00:00
rend = (struct run*)((char*)r + r->len);
if(r <= p && p < rend)
2006-06-12 15:22:12 +00:00
panic("freeing free page");
2009-07-12 02:26:01 +00:00
if(rend == p){ // r before p: expand r to include p
2007-08-14 19:05:48 +00:00
r->len += len;
if(r->next && r->next == pend){ // r now next to r->next?
r->len += r->next->len;
r->next = r->next->next;
2006-06-12 15:22:12 +00:00
}
goto out;
2006-06-12 15:22:12 +00:00
}
2009-07-12 02:26:01 +00:00
if(pend == r){ // p before r: expand p to include, replace r
p->len = len + r->len;
p->next = r->next;
*rp = p;
goto out;
}
2006-06-12 15:22:12 +00:00
}
2007-08-14 19:05:48 +00:00
// Insert p before r in list.
2006-06-12 15:22:12 +00:00
p->len = len;
2007-08-14 19:05:48 +00:00
p->next = r;
*rp = p;
out:
release(&kmem.lock);
2006-06-12 15:22:12 +00:00
}
2006-09-06 17:50:20 +00:00
// Allocate n bytes of physical memory.
// Returns a kernel-segment pointer.
// Returns 0 if the memory cannot be allocated.
2006-07-16 16:05:37 +00:00
char*
2006-06-12 15:22:12 +00:00
kalloc(int n)
{
2007-08-10 17:02:36 +00:00
char *p;
2007-08-27 12:50:36 +00:00
struct run *r, **rp;
2006-06-12 15:22:12 +00:00
2007-08-24 19:32:36 +00:00
if(n % PAGE || n <= 0)
2006-06-12 15:22:12 +00:00
panic("kalloc");
acquire(&kmem.lock);
for(rp=&kmem.freelist; (r=*rp) != 0; rp=&r->next){
2009-07-12 02:26:01 +00:00
if(r->len >= n){
2006-06-12 15:22:12 +00:00
r->len -= n;
2007-08-10 17:02:36 +00:00
p = (char*)r + r->len;
2009-07-12 02:26:01 +00:00
if(r->len == 0)
*rp = r->next;
release(&kmem.lock);
2006-06-12 15:22:12 +00:00
return p;
}
}
release(&kmem.lock);
2007-08-27 12:50:36 +00:00
2006-08-30 18:55:06 +00:00
cprintf("kalloc: out of memory\n");
2006-06-12 15:22:12 +00:00
return 0;
}