mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-23 09:19:51 +00:00
![Kees Cook](/assets/img/avatar_default.png)
The kmalloc() function has a 2-factor argument form, kmalloc_array(). This patch replaces cases of: kmalloc(a * b, gfp) with: kmalloc_array(a * b, gfp) as well as handling cases of: kmalloc(a * b * c, gfp) with: kmalloc(array3_size(a, b, c), gfp) as it's slightly less ugly than: kmalloc_array(array_size(a, b), c, gfp) This does, however, attempt to ignore constant size factors like: kmalloc(4 * 1024, gfp) though any constants defined via macros get caught up in the conversion. Any factors with a sizeof() of "unsigned char", "char", and "u8" were dropped, since they're redundant. The tools/ directory was manually excluded, since it has its own implementation of kmalloc(). The Coccinelle script used for this was: // Fix redundant parens around sizeof(). @@ type TYPE; expression THING, E; @@ ( kmalloc( - (sizeof(TYPE)) * E + sizeof(TYPE) * E , ...) | kmalloc( - (sizeof(THING)) * E + sizeof(THING) * E , ...) ) // Drop single-byte sizes and redundant parens. @@ expression COUNT; typedef u8; typedef __u8; @@ ( kmalloc( - sizeof(u8) * (COUNT) + COUNT , ...) | kmalloc( - sizeof(__u8) * (COUNT) + COUNT , ...) | kmalloc( - sizeof(char) * (COUNT) + COUNT , ...) | kmalloc( - sizeof(unsigned char) * (COUNT) + COUNT , ...) | kmalloc( - sizeof(u8) * COUNT + COUNT , ...) | kmalloc( - sizeof(__u8) * COUNT + COUNT , ...) | kmalloc( - sizeof(char) * COUNT + COUNT , ...) | kmalloc( - sizeof(unsigned char) * COUNT + COUNT , ...) ) // 2-factor product with sizeof(type/expression) and identifier or constant. @@ type TYPE; expression THING; identifier COUNT_ID; constant COUNT_CONST; @@ ( - kmalloc + kmalloc_array ( - sizeof(TYPE) * (COUNT_ID) + COUNT_ID, sizeof(TYPE) , ...) | - kmalloc + kmalloc_array ( - sizeof(TYPE) * COUNT_ID + COUNT_ID, sizeof(TYPE) , ...) | - kmalloc + kmalloc_array ( - sizeof(TYPE) * (COUNT_CONST) + COUNT_CONST, sizeof(TYPE) , ...) | - kmalloc + kmalloc_array ( - sizeof(TYPE) * COUNT_CONST + COUNT_CONST, sizeof(TYPE) , ...) | - kmalloc + kmalloc_array ( - sizeof(THING) * (COUNT_ID) + COUNT_ID, sizeof(THING) , ...) | - kmalloc + kmalloc_array ( - sizeof(THING) * COUNT_ID + COUNT_ID, sizeof(THING) , ...) | - kmalloc + kmalloc_array ( - sizeof(THING) * (COUNT_CONST) + COUNT_CONST, sizeof(THING) , ...) | - kmalloc + kmalloc_array ( - sizeof(THING) * COUNT_CONST + COUNT_CONST, sizeof(THING) , ...) ) // 2-factor product, only identifiers. @@ identifier SIZE, COUNT; @@ - kmalloc + kmalloc_array ( - SIZE * COUNT + COUNT, SIZE , ...) // 3-factor product with 1 sizeof(type) or sizeof(expression), with // redundant parens removed. @@ expression THING; identifier STRIDE, COUNT; type TYPE; @@ ( kmalloc( - sizeof(TYPE) * (COUNT) * (STRIDE) + array3_size(COUNT, STRIDE, sizeof(TYPE)) , ...) | kmalloc( - sizeof(TYPE) * (COUNT) * STRIDE + array3_size(COUNT, STRIDE, sizeof(TYPE)) , ...) | kmalloc( - sizeof(TYPE) * COUNT * (STRIDE) + array3_size(COUNT, STRIDE, sizeof(TYPE)) , ...) | kmalloc( - sizeof(TYPE) * COUNT * STRIDE + array3_size(COUNT, STRIDE, sizeof(TYPE)) , ...) | kmalloc( - sizeof(THING) * (COUNT) * (STRIDE) + array3_size(COUNT, STRIDE, sizeof(THING)) , ...) | kmalloc( - sizeof(THING) * (COUNT) * STRIDE + array3_size(COUNT, STRIDE, sizeof(THING)) , ...) | kmalloc( - sizeof(THING) * COUNT * (STRIDE) + array3_size(COUNT, STRIDE, sizeof(THING)) , ...) | kmalloc( - sizeof(THING) * COUNT * STRIDE + array3_size(COUNT, STRIDE, sizeof(THING)) , ...) ) // 3-factor product with 2 sizeof(variable), with redundant parens removed. @@ expression THING1, THING2; identifier COUNT; type TYPE1, TYPE2; @@ ( kmalloc( - sizeof(TYPE1) * sizeof(TYPE2) * COUNT + array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2)) , ...) | kmalloc( - sizeof(TYPE1) * sizeof(THING2) * (COUNT) + array3_size(COUNT, sizeof(TYPE1), sizeof(TYPE2)) , ...) | kmalloc( - sizeof(THING1) * sizeof(THING2) * COUNT + array3_size(COUNT, sizeof(THING1), sizeof(THING2)) , ...) | kmalloc( - sizeof(THING1) * sizeof(THING2) * (COUNT) + array3_size(COUNT, sizeof(THING1), sizeof(THING2)) , ...) | kmalloc( - sizeof(TYPE1) * sizeof(THING2) * COUNT + array3_size(COUNT, sizeof(TYPE1), sizeof(THING2)) , ...) | kmalloc( - sizeof(TYPE1) * sizeof(THING2) * (COUNT) + array3_size(COUNT, sizeof(TYPE1), sizeof(THING2)) , ...) ) // 3-factor product, only identifiers, with redundant parens removed. @@ identifier STRIDE, SIZE, COUNT; @@ ( kmalloc( - (COUNT) * STRIDE * SIZE + array3_size(COUNT, STRIDE, SIZE) , ...) | kmalloc( - COUNT * (STRIDE) * SIZE + array3_size(COUNT, STRIDE, SIZE) , ...) | kmalloc( - COUNT * STRIDE * (SIZE) + array3_size(COUNT, STRIDE, SIZE) , ...) | kmalloc( - (COUNT) * (STRIDE) * SIZE + array3_size(COUNT, STRIDE, SIZE) , ...) | kmalloc( - COUNT * (STRIDE) * (SIZE) + array3_size(COUNT, STRIDE, SIZE) , ...) | kmalloc( - (COUNT) * STRIDE * (SIZE) + array3_size(COUNT, STRIDE, SIZE) , ...) | kmalloc( - (COUNT) * (STRIDE) * (SIZE) + array3_size(COUNT, STRIDE, SIZE) , ...) | kmalloc( - COUNT * STRIDE * SIZE + array3_size(COUNT, STRIDE, SIZE) , ...) ) // Any remaining multi-factor products, first at least 3-factor products, // when they're not all constants... @@ expression E1, E2, E3; constant C1, C2, C3; @@ ( kmalloc(C1 * C2 * C3, ...) | kmalloc( - (E1) * E2 * E3 + array3_size(E1, E2, E3) , ...) | kmalloc( - (E1) * (E2) * E3 + array3_size(E1, E2, E3) , ...) | kmalloc( - (E1) * (E2) * (E3) + array3_size(E1, E2, E3) , ...) | kmalloc( - E1 * E2 * E3 + array3_size(E1, E2, E3) , ...) ) // And then all remaining 2 factors products when they're not all constants, // keeping sizeof() as the second factor argument. @@ expression THING, E1, E2; type TYPE; constant C1, C2, C3; @@ ( kmalloc(sizeof(THING) * C2, ...) | kmalloc(sizeof(TYPE) * C2, ...) | kmalloc(C1 * C2 * C3, ...) | kmalloc(C1 * C2, ...) | - kmalloc + kmalloc_array ( - sizeof(TYPE) * (E2) + E2, sizeof(TYPE) , ...) | - kmalloc + kmalloc_array ( - sizeof(TYPE) * E2 + E2, sizeof(TYPE) , ...) | - kmalloc + kmalloc_array ( - sizeof(THING) * (E2) + E2, sizeof(THING) , ...) | - kmalloc + kmalloc_array ( - sizeof(THING) * E2 + E2, sizeof(THING) , ...) | - kmalloc + kmalloc_array ( - (E1) * E2 + E1, E2 , ...) | - kmalloc + kmalloc_array ( - (E1) * (E2) + E1, E2 , ...) | - kmalloc + kmalloc_array ( - E1 * E2 + E1, E2 , ...) ) Signed-off-by: Kees Cook <keescook@chromium.org>
747 lines
16 KiB
C
747 lines
16 KiB
C
/*
|
|
* A Remote Heap. Remote means that we don't touch the memory that the
|
|
* heap points to. Normal heap implementations use the memory they manage
|
|
* to place their list. We cannot do that because the memory we manage may
|
|
* have special properties, for example it is uncachable or of different
|
|
* endianess.
|
|
*
|
|
* Author: Pantelis Antoniou <panto@intracom.gr>
|
|
*
|
|
* 2004 (c) INTRACOM S.A. Greece. This file is licensed under
|
|
* the terms of the GNU General Public License version 2. This program
|
|
* is licensed "as is" without any warranty of any kind, whether express
|
|
* or implied.
|
|
*/
|
|
#include <linux/types.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/export.h>
|
|
#include <linux/mm.h>
|
|
#include <linux/err.h>
|
|
#include <linux/slab.h>
|
|
|
|
#include <asm/rheap.h>
|
|
|
|
/*
|
|
* Fixup a list_head, needed when copying lists. If the pointers fall
|
|
* between s and e, apply the delta. This assumes that
|
|
* sizeof(struct list_head *) == sizeof(unsigned long *).
|
|
*/
|
|
static inline void fixup(unsigned long s, unsigned long e, int d,
|
|
struct list_head *l)
|
|
{
|
|
unsigned long *pp;
|
|
|
|
pp = (unsigned long *)&l->next;
|
|
if (*pp >= s && *pp < e)
|
|
*pp += d;
|
|
|
|
pp = (unsigned long *)&l->prev;
|
|
if (*pp >= s && *pp < e)
|
|
*pp += d;
|
|
}
|
|
|
|
/* Grow the allocated blocks */
|
|
static int grow(rh_info_t * info, int max_blocks)
|
|
{
|
|
rh_block_t *block, *blk;
|
|
int i, new_blocks;
|
|
int delta;
|
|
unsigned long blks, blke;
|
|
|
|
if (max_blocks <= info->max_blocks)
|
|
return -EINVAL;
|
|
|
|
new_blocks = max_blocks - info->max_blocks;
|
|
|
|
block = kmalloc_array(max_blocks, sizeof(rh_block_t), GFP_ATOMIC);
|
|
if (block == NULL)
|
|
return -ENOMEM;
|
|
|
|
if (info->max_blocks > 0) {
|
|
|
|
/* copy old block area */
|
|
memcpy(block, info->block,
|
|
sizeof(rh_block_t) * info->max_blocks);
|
|
|
|
delta = (char *)block - (char *)info->block;
|
|
|
|
/* and fixup list pointers */
|
|
blks = (unsigned long)info->block;
|
|
blke = (unsigned long)(info->block + info->max_blocks);
|
|
|
|
for (i = 0, blk = block; i < info->max_blocks; i++, blk++)
|
|
fixup(blks, blke, delta, &blk->list);
|
|
|
|
fixup(blks, blke, delta, &info->empty_list);
|
|
fixup(blks, blke, delta, &info->free_list);
|
|
fixup(blks, blke, delta, &info->taken_list);
|
|
|
|
/* free the old allocated memory */
|
|
if ((info->flags & RHIF_STATIC_BLOCK) == 0)
|
|
kfree(info->block);
|
|
}
|
|
|
|
info->block = block;
|
|
info->empty_slots += new_blocks;
|
|
info->max_blocks = max_blocks;
|
|
info->flags &= ~RHIF_STATIC_BLOCK;
|
|
|
|
/* add all new blocks to the free list */
|
|
blk = block + info->max_blocks - new_blocks;
|
|
for (i = 0; i < new_blocks; i++, blk++)
|
|
list_add(&blk->list, &info->empty_list);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Assure at least the required amount of empty slots. If this function
|
|
* causes a grow in the block area then all pointers kept to the block
|
|
* area are invalid!
|
|
*/
|
|
static int assure_empty(rh_info_t * info, int slots)
|
|
{
|
|
int max_blocks;
|
|
|
|
/* This function is not meant to be used to grow uncontrollably */
|
|
if (slots >= 4)
|
|
return -EINVAL;
|
|
|
|
/* Enough space */
|
|
if (info->empty_slots >= slots)
|
|
return 0;
|
|
|
|
/* Next 16 sized block */
|
|
max_blocks = ((info->max_blocks + slots) + 15) & ~15;
|
|
|
|
return grow(info, max_blocks);
|
|
}
|
|
|
|
static rh_block_t *get_slot(rh_info_t * info)
|
|
{
|
|
rh_block_t *blk;
|
|
|
|
/* If no more free slots, and failure to extend. */
|
|
/* XXX: You should have called assure_empty before */
|
|
if (info->empty_slots == 0) {
|
|
printk(KERN_ERR "rh: out of slots; crash is imminent.\n");
|
|
return NULL;
|
|
}
|
|
|
|
/* Get empty slot to use */
|
|
blk = list_entry(info->empty_list.next, rh_block_t, list);
|
|
list_del_init(&blk->list);
|
|
info->empty_slots--;
|
|
|
|
/* Initialize */
|
|
blk->start = 0;
|
|
blk->size = 0;
|
|
blk->owner = NULL;
|
|
|
|
return blk;
|
|
}
|
|
|
|
static inline void release_slot(rh_info_t * info, rh_block_t * blk)
|
|
{
|
|
list_add(&blk->list, &info->empty_list);
|
|
info->empty_slots++;
|
|
}
|
|
|
|
static void attach_free_block(rh_info_t * info, rh_block_t * blkn)
|
|
{
|
|
rh_block_t *blk;
|
|
rh_block_t *before;
|
|
rh_block_t *after;
|
|
rh_block_t *next;
|
|
int size;
|
|
unsigned long s, e, bs, be;
|
|
struct list_head *l;
|
|
|
|
/* We assume that they are aligned properly */
|
|
size = blkn->size;
|
|
s = blkn->start;
|
|
e = s + size;
|
|
|
|
/* Find the blocks immediately before and after the given one
|
|
* (if any) */
|
|
before = NULL;
|
|
after = NULL;
|
|
next = NULL;
|
|
|
|
list_for_each(l, &info->free_list) {
|
|
blk = list_entry(l, rh_block_t, list);
|
|
|
|
bs = blk->start;
|
|
be = bs + blk->size;
|
|
|
|
if (next == NULL && s >= bs)
|
|
next = blk;
|
|
|
|
if (be == s)
|
|
before = blk;
|
|
|
|
if (e == bs)
|
|
after = blk;
|
|
|
|
/* If both are not null, break now */
|
|
if (before != NULL && after != NULL)
|
|
break;
|
|
}
|
|
|
|
/* Now check if they are really adjacent */
|
|
if (before && s != (before->start + before->size))
|
|
before = NULL;
|
|
|
|
if (after && e != after->start)
|
|
after = NULL;
|
|
|
|
/* No coalescing; list insert and return */
|
|
if (before == NULL && after == NULL) {
|
|
|
|
if (next != NULL)
|
|
list_add(&blkn->list, &next->list);
|
|
else
|
|
list_add(&blkn->list, &info->free_list);
|
|
|
|
return;
|
|
}
|
|
|
|
/* We don't need it anymore */
|
|
release_slot(info, blkn);
|
|
|
|
/* Grow the before block */
|
|
if (before != NULL && after == NULL) {
|
|
before->size += size;
|
|
return;
|
|
}
|
|
|
|
/* Grow the after block backwards */
|
|
if (before == NULL && after != NULL) {
|
|
after->start -= size;
|
|
after->size += size;
|
|
return;
|
|
}
|
|
|
|
/* Grow the before block, and release the after block */
|
|
before->size += size + after->size;
|
|
list_del(&after->list);
|
|
release_slot(info, after);
|
|
}
|
|
|
|
static void attach_taken_block(rh_info_t * info, rh_block_t * blkn)
|
|
{
|
|
rh_block_t *blk;
|
|
struct list_head *l;
|
|
|
|
/* Find the block immediately before the given one (if any) */
|
|
list_for_each(l, &info->taken_list) {
|
|
blk = list_entry(l, rh_block_t, list);
|
|
if (blk->start > blkn->start) {
|
|
list_add_tail(&blkn->list, &blk->list);
|
|
return;
|
|
}
|
|
}
|
|
|
|
list_add_tail(&blkn->list, &info->taken_list);
|
|
}
|
|
|
|
/*
|
|
* Create a remote heap dynamically. Note that no memory for the blocks
|
|
* are allocated. It will upon the first allocation
|
|
*/
|
|
rh_info_t *rh_create(unsigned int alignment)
|
|
{
|
|
rh_info_t *info;
|
|
|
|
/* Alignment must be a power of two */
|
|
if ((alignment & (alignment - 1)) != 0)
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
info = kmalloc(sizeof(*info), GFP_ATOMIC);
|
|
if (info == NULL)
|
|
return ERR_PTR(-ENOMEM);
|
|
|
|
info->alignment = alignment;
|
|
|
|
/* Initially everything as empty */
|
|
info->block = NULL;
|
|
info->max_blocks = 0;
|
|
info->empty_slots = 0;
|
|
info->flags = 0;
|
|
|
|
INIT_LIST_HEAD(&info->empty_list);
|
|
INIT_LIST_HEAD(&info->free_list);
|
|
INIT_LIST_HEAD(&info->taken_list);
|
|
|
|
return info;
|
|
}
|
|
EXPORT_SYMBOL_GPL(rh_create);
|
|
|
|
/*
|
|
* Destroy a dynamically created remote heap. Deallocate only if the areas
|
|
* are not static
|
|
*/
|
|
void rh_destroy(rh_info_t * info)
|
|
{
|
|
if ((info->flags & RHIF_STATIC_BLOCK) == 0)
|
|
kfree(info->block);
|
|
|
|
if ((info->flags & RHIF_STATIC_INFO) == 0)
|
|
kfree(info);
|
|
}
|
|
EXPORT_SYMBOL_GPL(rh_destroy);
|
|
|
|
/*
|
|
* Initialize in place a remote heap info block. This is needed to support
|
|
* operation very early in the startup of the kernel, when it is not yet safe
|
|
* to call kmalloc.
|
|
*/
|
|
void rh_init(rh_info_t * info, unsigned int alignment, int max_blocks,
|
|
rh_block_t * block)
|
|
{
|
|
int i;
|
|
rh_block_t *blk;
|
|
|
|
/* Alignment must be a power of two */
|
|
if ((alignment & (alignment - 1)) != 0)
|
|
return;
|
|
|
|
info->alignment = alignment;
|
|
|
|
/* Initially everything as empty */
|
|
info->block = block;
|
|
info->max_blocks = max_blocks;
|
|
info->empty_slots = max_blocks;
|
|
info->flags = RHIF_STATIC_INFO | RHIF_STATIC_BLOCK;
|
|
|
|
INIT_LIST_HEAD(&info->empty_list);
|
|
INIT_LIST_HEAD(&info->free_list);
|
|
INIT_LIST_HEAD(&info->taken_list);
|
|
|
|
/* Add all new blocks to the free list */
|
|
for (i = 0, blk = block; i < max_blocks; i++, blk++)
|
|
list_add(&blk->list, &info->empty_list);
|
|
}
|
|
EXPORT_SYMBOL_GPL(rh_init);
|
|
|
|
/* Attach a free memory region, coalesces regions if adjacent */
|
|
int rh_attach_region(rh_info_t * info, unsigned long start, int size)
|
|
{
|
|
rh_block_t *blk;
|
|
unsigned long s, e, m;
|
|
int r;
|
|
|
|
/* The region must be aligned */
|
|
s = start;
|
|
e = s + size;
|
|
m = info->alignment - 1;
|
|
|
|
/* Round start up */
|
|
s = (s + m) & ~m;
|
|
|
|
/* Round end down */
|
|
e = e & ~m;
|
|
|
|
if (IS_ERR_VALUE(e) || (e < s))
|
|
return -ERANGE;
|
|
|
|
/* Take final values */
|
|
start = s;
|
|
size = e - s;
|
|
|
|
/* Grow the blocks, if needed */
|
|
r = assure_empty(info, 1);
|
|
if (r < 0)
|
|
return r;
|
|
|
|
blk = get_slot(info);
|
|
blk->start = start;
|
|
blk->size = size;
|
|
blk->owner = NULL;
|
|
|
|
attach_free_block(info, blk);
|
|
|
|
return 0;
|
|
}
|
|
EXPORT_SYMBOL_GPL(rh_attach_region);
|
|
|
|
/* Detatch given address range, splits free block if needed. */
|
|
unsigned long rh_detach_region(rh_info_t * info, unsigned long start, int size)
|
|
{
|
|
struct list_head *l;
|
|
rh_block_t *blk, *newblk;
|
|
unsigned long s, e, m, bs, be;
|
|
|
|
/* Validate size */
|
|
if (size <= 0)
|
|
return (unsigned long) -EINVAL;
|
|
|
|
/* The region must be aligned */
|
|
s = start;
|
|
e = s + size;
|
|
m = info->alignment - 1;
|
|
|
|
/* Round start up */
|
|
s = (s + m) & ~m;
|
|
|
|
/* Round end down */
|
|
e = e & ~m;
|
|
|
|
if (assure_empty(info, 1) < 0)
|
|
return (unsigned long) -ENOMEM;
|
|
|
|
blk = NULL;
|
|
list_for_each(l, &info->free_list) {
|
|
blk = list_entry(l, rh_block_t, list);
|
|
/* The range must lie entirely inside one free block */
|
|
bs = blk->start;
|
|
be = blk->start + blk->size;
|
|
if (s >= bs && e <= be)
|
|
break;
|
|
blk = NULL;
|
|
}
|
|
|
|
if (blk == NULL)
|
|
return (unsigned long) -ENOMEM;
|
|
|
|
/* Perfect fit */
|
|
if (bs == s && be == e) {
|
|
/* Delete from free list, release slot */
|
|
list_del(&blk->list);
|
|
release_slot(info, blk);
|
|
return s;
|
|
}
|
|
|
|
/* blk still in free list, with updated start and/or size */
|
|
if (bs == s || be == e) {
|
|
if (bs == s)
|
|
blk->start += size;
|
|
blk->size -= size;
|
|
|
|
} else {
|
|
/* The front free fragment */
|
|
blk->size = s - bs;
|
|
|
|
/* the back free fragment */
|
|
newblk = get_slot(info);
|
|
newblk->start = e;
|
|
newblk->size = be - e;
|
|
|
|
list_add(&newblk->list, &blk->list);
|
|
}
|
|
|
|
return s;
|
|
}
|
|
EXPORT_SYMBOL_GPL(rh_detach_region);
|
|
|
|
/* Allocate a block of memory at the specified alignment. The value returned
|
|
* is an offset into the buffer initialized by rh_init(), or a negative number
|
|
* if there is an error.
|
|
*/
|
|
unsigned long rh_alloc_align(rh_info_t * info, int size, int alignment, const char *owner)
|
|
{
|
|
struct list_head *l;
|
|
rh_block_t *blk;
|
|
rh_block_t *newblk;
|
|
unsigned long start, sp_size;
|
|
|
|
/* Validate size, and alignment must be power of two */
|
|
if (size <= 0 || (alignment & (alignment - 1)) != 0)
|
|
return (unsigned long) -EINVAL;
|
|
|
|
/* Align to configured alignment */
|
|
size = (size + (info->alignment - 1)) & ~(info->alignment - 1);
|
|
|
|
if (assure_empty(info, 2) < 0)
|
|
return (unsigned long) -ENOMEM;
|
|
|
|
blk = NULL;
|
|
list_for_each(l, &info->free_list) {
|
|
blk = list_entry(l, rh_block_t, list);
|
|
if (size <= blk->size) {
|
|
start = (blk->start + alignment - 1) & ~(alignment - 1);
|
|
if (start + size <= blk->start + blk->size)
|
|
break;
|
|
}
|
|
blk = NULL;
|
|
}
|
|
|
|
if (blk == NULL)
|
|
return (unsigned long) -ENOMEM;
|
|
|
|
/* Just fits */
|
|
if (blk->size == size) {
|
|
/* Move from free list to taken list */
|
|
list_del(&blk->list);
|
|
newblk = blk;
|
|
} else {
|
|
/* Fragment caused, split if needed */
|
|
/* Create block for fragment in the beginning */
|
|
sp_size = start - blk->start;
|
|
if (sp_size) {
|
|
rh_block_t *spblk;
|
|
|
|
spblk = get_slot(info);
|
|
spblk->start = blk->start;
|
|
spblk->size = sp_size;
|
|
/* add before the blk */
|
|
list_add(&spblk->list, blk->list.prev);
|
|
}
|
|
newblk = get_slot(info);
|
|
newblk->start = start;
|
|
newblk->size = size;
|
|
|
|
/* blk still in free list, with updated start and size
|
|
* for fragment in the end */
|
|
blk->start = start + size;
|
|
blk->size -= sp_size + size;
|
|
/* No fragment in the end, remove blk */
|
|
if (blk->size == 0) {
|
|
list_del(&blk->list);
|
|
release_slot(info, blk);
|
|
}
|
|
}
|
|
|
|
newblk->owner = owner;
|
|
attach_taken_block(info, newblk);
|
|
|
|
return start;
|
|
}
|
|
EXPORT_SYMBOL_GPL(rh_alloc_align);
|
|
|
|
/* Allocate a block of memory at the default alignment. The value returned is
|
|
* an offset into the buffer initialized by rh_init(), or a negative number if
|
|
* there is an error.
|
|
*/
|
|
unsigned long rh_alloc(rh_info_t * info, int size, const char *owner)
|
|
{
|
|
return rh_alloc_align(info, size, info->alignment, owner);
|
|
}
|
|
EXPORT_SYMBOL_GPL(rh_alloc);
|
|
|
|
/* Allocate a block of memory at the given offset, rounded up to the default
|
|
* alignment. The value returned is an offset into the buffer initialized by
|
|
* rh_init(), or a negative number if there is an error.
|
|
*/
|
|
unsigned long rh_alloc_fixed(rh_info_t * info, unsigned long start, int size, const char *owner)
|
|
{
|
|
struct list_head *l;
|
|
rh_block_t *blk, *newblk1, *newblk2;
|
|
unsigned long s, e, m, bs = 0, be = 0;
|
|
|
|
/* Validate size */
|
|
if (size <= 0)
|
|
return (unsigned long) -EINVAL;
|
|
|
|
/* The region must be aligned */
|
|
s = start;
|
|
e = s + size;
|
|
m = info->alignment - 1;
|
|
|
|
/* Round start up */
|
|
s = (s + m) & ~m;
|
|
|
|
/* Round end down */
|
|
e = e & ~m;
|
|
|
|
if (assure_empty(info, 2) < 0)
|
|
return (unsigned long) -ENOMEM;
|
|
|
|
blk = NULL;
|
|
list_for_each(l, &info->free_list) {
|
|
blk = list_entry(l, rh_block_t, list);
|
|
/* The range must lie entirely inside one free block */
|
|
bs = blk->start;
|
|
be = blk->start + blk->size;
|
|
if (s >= bs && e <= be)
|
|
break;
|
|
blk = NULL;
|
|
}
|
|
|
|
if (blk == NULL)
|
|
return (unsigned long) -ENOMEM;
|
|
|
|
/* Perfect fit */
|
|
if (bs == s && be == e) {
|
|
/* Move from free list to taken list */
|
|
list_del(&blk->list);
|
|
blk->owner = owner;
|
|
|
|
start = blk->start;
|
|
attach_taken_block(info, blk);
|
|
|
|
return start;
|
|
|
|
}
|
|
|
|
/* blk still in free list, with updated start and/or size */
|
|
if (bs == s || be == e) {
|
|
if (bs == s)
|
|
blk->start += size;
|
|
blk->size -= size;
|
|
|
|
} else {
|
|
/* The front free fragment */
|
|
blk->size = s - bs;
|
|
|
|
/* The back free fragment */
|
|
newblk2 = get_slot(info);
|
|
newblk2->start = e;
|
|
newblk2->size = be - e;
|
|
|
|
list_add(&newblk2->list, &blk->list);
|
|
}
|
|
|
|
newblk1 = get_slot(info);
|
|
newblk1->start = s;
|
|
newblk1->size = e - s;
|
|
newblk1->owner = owner;
|
|
|
|
start = newblk1->start;
|
|
attach_taken_block(info, newblk1);
|
|
|
|
return start;
|
|
}
|
|
EXPORT_SYMBOL_GPL(rh_alloc_fixed);
|
|
|
|
/* Deallocate the memory previously allocated by one of the rh_alloc functions.
|
|
* The return value is the size of the deallocated block, or a negative number
|
|
* if there is an error.
|
|
*/
|
|
int rh_free(rh_info_t * info, unsigned long start)
|
|
{
|
|
rh_block_t *blk, *blk2;
|
|
struct list_head *l;
|
|
int size;
|
|
|
|
/* Linear search for block */
|
|
blk = NULL;
|
|
list_for_each(l, &info->taken_list) {
|
|
blk2 = list_entry(l, rh_block_t, list);
|
|
if (start < blk2->start)
|
|
break;
|
|
blk = blk2;
|
|
}
|
|
|
|
if (blk == NULL || start > (blk->start + blk->size))
|
|
return -EINVAL;
|
|
|
|
/* Remove from taken list */
|
|
list_del(&blk->list);
|
|
|
|
/* Get size of freed block */
|
|
size = blk->size;
|
|
attach_free_block(info, blk);
|
|
|
|
return size;
|
|
}
|
|
EXPORT_SYMBOL_GPL(rh_free);
|
|
|
|
int rh_get_stats(rh_info_t * info, int what, int max_stats, rh_stats_t * stats)
|
|
{
|
|
rh_block_t *blk;
|
|
struct list_head *l;
|
|
struct list_head *h;
|
|
int nr;
|
|
|
|
switch (what) {
|
|
|
|
case RHGS_FREE:
|
|
h = &info->free_list;
|
|
break;
|
|
|
|
case RHGS_TAKEN:
|
|
h = &info->taken_list;
|
|
break;
|
|
|
|
default:
|
|
return -EINVAL;
|
|
}
|
|
|
|
/* Linear search for block */
|
|
nr = 0;
|
|
list_for_each(l, h) {
|
|
blk = list_entry(l, rh_block_t, list);
|
|
if (stats != NULL && nr < max_stats) {
|
|
stats->start = blk->start;
|
|
stats->size = blk->size;
|
|
stats->owner = blk->owner;
|
|
stats++;
|
|
}
|
|
nr++;
|
|
}
|
|
|
|
return nr;
|
|
}
|
|
EXPORT_SYMBOL_GPL(rh_get_stats);
|
|
|
|
int rh_set_owner(rh_info_t * info, unsigned long start, const char *owner)
|
|
{
|
|
rh_block_t *blk, *blk2;
|
|
struct list_head *l;
|
|
int size;
|
|
|
|
/* Linear search for block */
|
|
blk = NULL;
|
|
list_for_each(l, &info->taken_list) {
|
|
blk2 = list_entry(l, rh_block_t, list);
|
|
if (start < blk2->start)
|
|
break;
|
|
blk = blk2;
|
|
}
|
|
|
|
if (blk == NULL || start > (blk->start + blk->size))
|
|
return -EINVAL;
|
|
|
|
blk->owner = owner;
|
|
size = blk->size;
|
|
|
|
return size;
|
|
}
|
|
EXPORT_SYMBOL_GPL(rh_set_owner);
|
|
|
|
void rh_dump(rh_info_t * info)
|
|
{
|
|
static rh_stats_t st[32]; /* XXX maximum 32 blocks */
|
|
int maxnr;
|
|
int i, nr;
|
|
|
|
maxnr = ARRAY_SIZE(st);
|
|
|
|
printk(KERN_INFO
|
|
"info @0x%p (%d slots empty / %d max)\n",
|
|
info, info->empty_slots, info->max_blocks);
|
|
|
|
printk(KERN_INFO " Free:\n");
|
|
nr = rh_get_stats(info, RHGS_FREE, maxnr, st);
|
|
if (nr > maxnr)
|
|
nr = maxnr;
|
|
for (i = 0; i < nr; i++)
|
|
printk(KERN_INFO
|
|
" 0x%lx-0x%lx (%u)\n",
|
|
st[i].start, st[i].start + st[i].size,
|
|
st[i].size);
|
|
printk(KERN_INFO "\n");
|
|
|
|
printk(KERN_INFO " Taken:\n");
|
|
nr = rh_get_stats(info, RHGS_TAKEN, maxnr, st);
|
|
if (nr > maxnr)
|
|
nr = maxnr;
|
|
for (i = 0; i < nr; i++)
|
|
printk(KERN_INFO
|
|
" 0x%lx-0x%lx (%u) %s\n",
|
|
st[i].start, st[i].start + st[i].size,
|
|
st[i].size, st[i].owner != NULL ? st[i].owner : "");
|
|
printk(KERN_INFO "\n");
|
|
}
|
|
EXPORT_SYMBOL_GPL(rh_dump);
|
|
|
|
void rh_dump_blk(rh_info_t * info, rh_block_t * blk)
|
|
{
|
|
printk(KERN_INFO
|
|
"blk @0x%p: 0x%lx-0x%lx (%u)\n",
|
|
blk, blk->start, blk->start + blk->size, blk->size);
|
|
}
|
|
EXPORT_SYMBOL_GPL(rh_dump_blk);
|
|
|