parent
5177dd6cf1
commit
e87cbf74c7
@ -0,0 +1,232 @@
|
|||||||
|
/*
|
||||||
|
* malloc.c --- a general purpose kernel memory allocator for Linux.
|
||||||
|
*
|
||||||
|
* Written by Theodore Ts'o (tytso@mit.edu), 11/29/91
|
||||||
|
*
|
||||||
|
* This routine is written to be as fast as possible, so that it
|
||||||
|
* can be called from the interrupt level.
|
||||||
|
*
|
||||||
|
* Limitations: maximum size of memory we can allocate using this routine
|
||||||
|
* is 4k, the size of a page in Linux.
|
||||||
|
*
|
||||||
|
* The general game plan is that each page (called a bucket) will only hold
|
||||||
|
* objects of a given size. When all of the object on a page are released,
|
||||||
|
* the page can be returned to the general free pool. When malloc() is
|
||||||
|
* called, it looks for the smallest bucket size which will fulfill its
|
||||||
|
* request, and allocate a piece of memory from that bucket pool.
|
||||||
|
*
|
||||||
|
* Each bucket has as its control block a bucket descriptor which keeps
|
||||||
|
* track of how many objects are in use on that page, and the free list
|
||||||
|
* for that page. Like the buckets themselves, bucket descriptors are
|
||||||
|
* stored on pages requested from get_free_page(). However, unlike buckets,
|
||||||
|
* pages devoted to bucket descriptor pages are never released back to the
|
||||||
|
* system. Fortunately, a system should probably only need 1 or 2 bucket
|
||||||
|
* descriptor pages, since a page can hold 256 bucket descriptors (which
|
||||||
|
* corresponds to 1 megabyte worth of bucket pages.) If the kernel is using
|
||||||
|
* that much allocated memory, it's probably doing something wrong. :-)
|
||||||
|
*
|
||||||
|
* Note: malloc() and free() both call get_free_page() and free_page()
|
||||||
|
* in sections of code where interrupts are turned off, to allow
|
||||||
|
* malloc() and free() to be safely called from an interrupt routine.
|
||||||
|
* (We will probably need this functionality when networking code,
|
||||||
|
* particularily things like NFS, is added to Linux.) However, this
|
||||||
|
* presumes that get_free_page() and free_page() are interrupt-level
|
||||||
|
* safe, which they may not be once paging is added. If this is the
|
||||||
|
* case, we will need to modify malloc() to keep a few unused pages
|
||||||
|
* "pre-allocated" so that it can safely draw upon those pages if
|
||||||
|
* it is called from an interrupt routine.
|
||||||
|
*
|
||||||
|
* Another concern is that get_free_page() should not sleep; if it
|
||||||
|
* does, the code is carefully ordered so as to avoid any race
|
||||||
|
* conditions. The catch is that if malloc() is called re-entrantly,
|
||||||
|
* there is a chance that unecessary pages will be grabbed from the
|
||||||
|
* system. Except for the pages for the bucket descriptor page, the
|
||||||
|
* extra pages will eventually get released back to the system, though,
|
||||||
|
* so it isn't all that bad.
|
||||||
|
*/
|
||||||
|
|
||||||
|
#include <linux/kernel.h>
|
||||||
|
#include <linux/mm.h>
|
||||||
|
#include <asm/system.h>
|
||||||
|
|
||||||
|
struct bucket_desc { /* 16 bytes */
|
||||||
|
void *page;
|
||||||
|
struct bucket_desc *next;
|
||||||
|
void *freeptr;
|
||||||
|
unsigned short refcnt;
|
||||||
|
unsigned short bucket_size;
|
||||||
|
};
|
||||||
|
|
||||||
|
struct _bucket_dir { /* 8 bytes */
|
||||||
|
int size;
|
||||||
|
struct bucket_desc *chain;
|
||||||
|
};
|
||||||
|
|
||||||
|
/*
|
||||||
|
* The following is the where we store a pointer to the first bucket
|
||||||
|
* descriptor for a given size.
|
||||||
|
*
|
||||||
|
* If it turns out that the Linux kernel allocates a lot of objects of a
|
||||||
|
* specific size, then we may want to add that specific size to this list,
|
||||||
|
* since that will allow the memory to be allocated more efficiently.
|
||||||
|
* However, since an entire page must be dedicated to each specific size
|
||||||
|
* on this list, some amount of temperance must be exercised here.
|
||||||
|
*
|
||||||
|
* Note that this list *must* be kept in order.
|
||||||
|
*/
|
||||||
|
struct _bucket_dir bucket_dir[] = {
|
||||||
|
{ 16, (struct bucket_desc *) 0},
|
||||||
|
{ 32, (struct bucket_desc *) 0},
|
||||||
|
{ 64, (struct bucket_desc *) 0},
|
||||||
|
{ 128, (struct bucket_desc *) 0},
|
||||||
|
{ 256, (struct bucket_desc *) 0},
|
||||||
|
{ 512, (struct bucket_desc *) 0},
|
||||||
|
{ 1024, (struct bucket_desc *) 0},
|
||||||
|
{ 2048, (struct bucket_desc *) 0},
|
||||||
|
{ 4096, (struct bucket_desc *) 0},
|
||||||
|
{ 0, (struct bucket_desc *) 0}}; /* End of list marker */
|
||||||
|
|
||||||
|
/*
|
||||||
|
* This contains a linked list of free bucket descriptor blocks
|
||||||
|
*/
|
||||||
|
struct bucket_desc *free_bucket_desc = (struct bucket_desc *) 0;
|
||||||
|
|
||||||
|
/*
|
||||||
|
* This routine initializes a bucket description page.
|
||||||
|
*/
|
||||||
|
static inline void init_bucket_desc()
|
||||||
|
{
|
||||||
|
struct bucket_desc *bdesc, *first;
|
||||||
|
int i;
|
||||||
|
|
||||||
|
first = bdesc = (struct bucket_desc *) get_free_page();
|
||||||
|
if (!bdesc)
|
||||||
|
panic("Out of memory in init_bucket_desc()");
|
||||||
|
for (i = PAGE_SIZE/sizeof(struct bucket_desc); i > 1; i--) {
|
||||||
|
bdesc->next = bdesc+1;
|
||||||
|
bdesc++;
|
||||||
|
}
|
||||||
|
/*
|
||||||
|
* This is done last, to avoid race conditions in case
|
||||||
|
* get_free_page() sleeps and this routine gets called again....
|
||||||
|
*/
|
||||||
|
bdesc->next = free_bucket_desc;
|
||||||
|
free_bucket_desc = first;
|
||||||
|
}
|
||||||
|
|
||||||
|
void *malloc(unsigned int len)
|
||||||
|
{
|
||||||
|
struct _bucket_dir *bdir;
|
||||||
|
struct bucket_desc *bdesc;
|
||||||
|
void *retval;
|
||||||
|
|
||||||
|
/*
|
||||||
|
* First we search the bucket_dir to find the right bucket change
|
||||||
|
* for this request.
|
||||||
|
*/
|
||||||
|
for (bdir = bucket_dir; bdir->size; bdir++)
|
||||||
|
if (bdir->size >= len)
|
||||||
|
break;
|
||||||
|
if (!bdir->size) {
|
||||||
|
printk("malloc called with impossibly large argument (%d)\n",
|
||||||
|
len);
|
||||||
|
panic("malloc: bad arg");
|
||||||
|
}
|
||||||
|
/*
|
||||||
|
* Now we search for a bucket descriptor which has free space
|
||||||
|
*/
|
||||||
|
cli(); /* Avoid race conditions */
|
||||||
|
for (bdesc = bdir->chain; bdesc; bdesc = bdesc->next)
|
||||||
|
if (bdesc->freeptr)
|
||||||
|
break;
|
||||||
|
/*
|
||||||
|
* If we didn't find a bucket with free space, then we'll
|
||||||
|
* allocate a new one.
|
||||||
|
*/
|
||||||
|
if (!bdesc) {
|
||||||
|
char *cp;
|
||||||
|
int i;
|
||||||
|
|
||||||
|
if (!free_bucket_desc)
|
||||||
|
init_bucket_desc();
|
||||||
|
bdesc = free_bucket_desc;
|
||||||
|
free_bucket_desc = bdesc->next;
|
||||||
|
bdesc->refcnt = 0;
|
||||||
|
bdesc->bucket_size = bdir->size;
|
||||||
|
bdesc->page = bdesc->freeptr = (void *) (cp = get_free_page());
|
||||||
|
if (!cp)
|
||||||
|
panic("Out of memory in kernel malloc()");
|
||||||
|
/* Set up the chain of free objects */
|
||||||
|
for (i=PAGE_SIZE/bdir->size; i > 1; i--) {
|
||||||
|
*((char **) cp) = cp + bdir->size;
|
||||||
|
cp += bdir->size;
|
||||||
|
}
|
||||||
|
*((char **) cp) = 0;
|
||||||
|
bdesc->next = bdir->chain; /* OK, link it in! */
|
||||||
|
bdir->chain = bdesc;
|
||||||
|
}
|
||||||
|
retval = (void *) bdesc->freeptr;
|
||||||
|
bdesc->freeptr = *((void **) retval);
|
||||||
|
bdesc->refcnt++;
|
||||||
|
sti(); /* OK, we're safe again */
|
||||||
|
return(retval);
|
||||||
|
}
|
||||||
|
|
||||||
|
/*
|
||||||
|
* Here is the free routine. If you know the size of the object that you
|
||||||
|
* are freeing, then free_s() will use that information to speed up the
|
||||||
|
* search for the bucket descriptor.
|
||||||
|
*
|
||||||
|
* We will #define a macro so that "free(x)" is becomes "free_s(x, 0)"
|
||||||
|
*/
|
||||||
|
void free_s(void *obj, int size)
|
||||||
|
{
|
||||||
|
void *page;
|
||||||
|
struct _bucket_dir *bdir;
|
||||||
|
struct bucket_desc *bdesc, *prev;
|
||||||
|
|
||||||
|
/* Calculate what page this object lives in */
|
||||||
|
page = (void *) ((unsigned long) obj & 0xfffff000);
|
||||||
|
/* Now search the buckets looking for that page */
|
||||||
|
for (bdir = bucket_dir; bdir->size; bdir++) {
|
||||||
|
prev = 0;
|
||||||
|
/* If size is zero then this conditional is always false */
|
||||||
|
if (bdir->size < size)
|
||||||
|
continue;
|
||||||
|
for (bdesc = bdir->chain; bdesc; bdesc = bdesc->next) {
|
||||||
|
if (bdesc->page == page)
|
||||||
|
goto found;
|
||||||
|
prev = bdesc;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
panic("Bad address passed to kernel free_s()");
|
||||||
|
found:
|
||||||
|
cli(); /* To avoid race conditions */
|
||||||
|
*((void **)obj) = bdesc->freeptr;
|
||||||
|
bdesc->freeptr = obj;
|
||||||
|
bdesc->refcnt--;
|
||||||
|
if (bdesc->refcnt == 0) {
|
||||||
|
/*
|
||||||
|
* We need to make sure that prev is still accurate. It
|
||||||
|
* may not be, if someone rudely interrupted us....
|
||||||
|
*/
|
||||||
|
if ((prev && (prev->next != bdesc)) ||
|
||||||
|
(!prev && (bdir->chain != bdesc)))
|
||||||
|
for (prev = bdir->chain; prev; prev = prev->next)
|
||||||
|
if (prev->next == bdesc)
|
||||||
|
break;
|
||||||
|
if (prev)
|
||||||
|
prev->next = bdesc->next;
|
||||||
|
else {
|
||||||
|
if (bdir->chain != bdesc)
|
||||||
|
panic("malloc bucket chains corrupted");
|
||||||
|
bdir->chain = bdesc->next;
|
||||||
|
}
|
||||||
|
free_page((unsigned long) bdesc->page);
|
||||||
|
bdesc->next = free_bucket_desc;
|
||||||
|
free_bucket_desc = bdesc;
|
||||||
|
}
|
||||||
|
sti();
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
|
||||||
Loading…
Reference in new issue