cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

simple_alloc.c (3617B)

      1/*
      2 * Implement primitive realloc(3) functionality.
      3 *
      4 * Author: Mark A. Greer <mgreer@mvista.com>
      5 *
      6 * 2006 (c) MontaVista, Software, Inc.  This file is licensed under
      7 * the terms of the GNU General Public License version 2.  This program
      8 * is licensed "as is" without any warranty of any kind, whether express
      9 * or implied.
     10 */
     11
     12#include <stddef.h>
     13#include "types.h"
     14#include "page.h"
     15#include "string.h"
     16#include "ops.h"
     17
     18#define	ENTRY_BEEN_USED	0x01
     19#define	ENTRY_IN_USE	0x02
     20
     21static struct alloc_info {
     22	unsigned long	flags;
     23	unsigned long	base;
     24	unsigned long	size;
     25} *alloc_tbl;
     26
     27static unsigned long tbl_entries;
     28static unsigned long alloc_min;
     29static unsigned long next_base;
     30static unsigned long space_left;
     31
     32/*
     33 * First time an entry is used, its base and size are set.
     34 * An entry can be freed and re-malloc'd but its base & size don't change.
     35 * Should be smart enough for needs of bootwrapper.
     36 */
     37static void *simple_malloc(unsigned long size)
     38{
     39	unsigned long i;
     40	struct alloc_info *p = alloc_tbl;
     41
     42	if (size == 0)
     43		goto err_out;
     44
     45	size = _ALIGN_UP(size, alloc_min);
     46
     47	for (i=0; i<tbl_entries; i++, p++)
     48		if (!(p->flags & ENTRY_BEEN_USED)) { /* never been used */
     49			if (size <= space_left) {
     50				p->base = next_base;
     51				p->size = size;
     52				p->flags = ENTRY_BEEN_USED | ENTRY_IN_USE;
     53				next_base += size;
     54				space_left -= size;
     55				return (void *)p->base;
     56			}
     57			goto err_out; /* not enough space left */
     58		}
     59		/* reuse an entry keeping same base & size */
     60		else if (!(p->flags & ENTRY_IN_USE) && (size <= p->size)) {
     61			p->flags |= ENTRY_IN_USE;
     62			return (void *)p->base;
     63		}
     64err_out:
     65	return NULL;
     66}
     67
     68static struct alloc_info *simple_find_entry(void *ptr)
     69{
     70	unsigned long i;
     71	struct alloc_info *p = alloc_tbl;
     72
     73	for (i=0; i<tbl_entries; i++,p++) {
     74		if (!(p->flags & ENTRY_BEEN_USED))
     75			break;
     76		if ((p->flags & ENTRY_IN_USE) &&
     77		    (p->base == (unsigned long)ptr))
     78			return p;
     79	}
     80	return NULL;
     81}
     82
     83static void simple_free(void *ptr)
     84{
     85	struct alloc_info *p = simple_find_entry(ptr);
     86
     87	if (p != NULL)
     88		p->flags &= ~ENTRY_IN_USE;
     89}
     90
     91/*
     92 * Change size of area pointed to by 'ptr' to 'size'.
     93 * If 'ptr' is NULL, then its a malloc().  If 'size' is 0, then its a free().
     94 * 'ptr' must be NULL or a pointer to a non-freed area previously returned by
     95 * simple_realloc() or simple_malloc().
     96 */
     97static void *simple_realloc(void *ptr, unsigned long size)
     98{
     99	struct alloc_info *p;
    100	void *new;
    101
    102	if (size == 0) {
    103		simple_free(ptr);
    104		return NULL;
    105	}
    106
    107	if (ptr == NULL)
    108		return simple_malloc(size);
    109
    110	p = simple_find_entry(ptr);
    111	if (p == NULL) /* ptr not from simple_malloc/simple_realloc */
    112		return NULL;
    113	if (size <= p->size) /* fits in current block */
    114		return ptr;
    115
    116	new = simple_malloc(size);
    117	memcpy(new, ptr, p->size);
    118	simple_free(ptr);
    119	return new;
    120}
    121
    122/*
    123 * Returns addr of first byte after heap so caller can see if it took
    124 * too much space.  If so, change args & try again.
    125 */
    126void *simple_alloc_init(char *base, unsigned long heap_size,
    127			unsigned long granularity, unsigned long max_allocs)
    128{
    129	unsigned long heap_base, tbl_size;
    130
    131	heap_size = _ALIGN_UP(heap_size, granularity);
    132	alloc_min = granularity;
    133	tbl_entries = max_allocs;
    134
    135	tbl_size = tbl_entries * sizeof(struct alloc_info);
    136
    137	alloc_tbl = (struct alloc_info *)_ALIGN_UP((unsigned long)base, 8);
    138	memset(alloc_tbl, 0, tbl_size);
    139
    140	heap_base = _ALIGN_UP((unsigned long)alloc_tbl + tbl_size, alloc_min);
    141
    142	next_base = heap_base;
    143	space_left = heap_size;
    144
    145	platform_ops.malloc = simple_malloc;
    146	platform_ops.free = simple_free;
    147	platform_ops.realloc = simple_realloc;
    148
    149	return (void *)(heap_base + heap_size);
    150}