github/acrn-hypervisor
1
0
Fork 0
mirror of https://github.com/projectacrn/acrn-hypervisor.git synced 2025-06-19 12:12:16 +00:00
Code Issues Projects Releases Wiki Activity

Removed dead funcs in EFI stub module

Browse Source 
Due to the last patches, some funcs in malloc.c and stdlib.h files for
EFI stub module are no longer used. This commit just removes them, no
other changes is being introduced. The funcs are:
    emalloc/efree, calloc/malloc/free, strstr/strdup

Tracked-On:#1260
Signed-off-by: Chaohong Guo <chaohong.guo@intel.com>
Ackedr-by: Gen Zheng <gen.zheng@intel.com>
This commit is contained in:
Chaohong guo 2018-09-17 14:26:38 +08:00 committed by lijinxia
parent 1d15b98730
commit 0306bb47c8
2 changed files with 0 additions and 177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

137
hypervisor/bsp/uefi/efi/malloc.c
View File

@ -93,143 +93,6 @@ failed:
return err;
}
/**
* emalloc - Allocate memory with a strict alignment requirement
* @size: size in bytes of the requested allocation
* @align: the required alignment of the allocation
* @addr: a pointer to the allocated address on success
*
* If we cannot satisfy @align we return 0.
*
* FIXME: This function cannot guarantee to return address under 4G,
* and the hypervisor cannot handle params, which address is above 4G,
* delivered from efi stub.
*/
EFI_STATUS emalloc(UINTN size, UINTN align, EFI_PHYSICAL_ADDRESS *addr)
{
UINTN map_size, map_key, desc_size;
EFI_MEMORY_DESCRIPTOR *map_buf;
UINTN d, map_end;
UINT32 desc_version;
EFI_STATUS err;
UINTN nr_pages = EFI_SIZE_TO_PAGES(size);
err = memory_map(&map_buf, &map_size, &map_key,
&desc_size, &desc_version);
if (err != EFI_SUCCESS)
goto fail;
d = (UINTN)map_buf;
map_end = (UINTN)map_buf + map_size;
for (; d < map_end; d += desc_size) {
EFI_MEMORY_DESCRIPTOR *desc;
EFI_PHYSICAL_ADDRESS start, end, aligned;
desc = (EFI_MEMORY_DESCRIPTOR *)d;
if (desc->Type != EfiConventionalMemory)
continue;
if (desc->NumberOfPages < nr_pages)
continue;
start = desc->PhysicalStart;
end = start + (desc->NumberOfPages << EFI_PAGE_SHIFT);
/* Low-memory is super-precious! */
if (end <= 1 << 20)
continue;
if (start < 1 << 20) {
size -= (1 << 20) - start;
start = (1 << 20);
}
aligned = (start + align -1) & ~(align -1);
if ((aligned + size) <= end) {
err = allocate_pages(AllocateAddress, EfiLoaderData,
nr_pages, &aligned);
if (err == EFI_SUCCESS) {
*addr = aligned;
break;
}
}
}
if (d == map_end)
err = EFI_OUT_OF_RESOURCES;
free_pool(map_buf);
fail:
return err;
}
/**
* efree - Return memory allocated with emalloc
* @memory: the address of the emalloc() allocation
* @size: the size of the allocation
*/
void efree(EFI_PHYSICAL_ADDRESS memory, UINTN size)
{
UINTN nr_pages = EFI_SIZE_TO_PAGES(size);
free_pages(memory, nr_pages);
}
/**
* malloc - Allocate memory from the EfiLoaderData pool
* @size: size in bytes of the requested allocation
*
* Return a pointer to an allocation of @size bytes of type
* EfiLoaderData.
*/
void *malloc(UINTN size)
{
EFI_STATUS err;
void *buffer;
err = allocate_pool(EfiLoaderData, size, &buffer);
if (err != EFI_SUCCESS)
buffer = NULL;
return buffer;
}
/**
* free - Release memory to the EfiLoaderData pool
* @buffer: pointer to the malloc() allocation to free
*/
void free(void *buffer)
{
if (buffer)
free_pool(buffer);
}
/**
* calloc - Allocate zeroed memory for an array of elements
* @nmemb: number of elements
* @size: size of each element
*/
void *calloc(UINTN nmemb, UINTN size)
{
void *buffer;
/*
* There's no equivalent of UINTN_MAX, so for safety we refuse to
* allocate anything larger than 32 bits.
*/
UINTN bytes = nmemb * size;
if ((nmemb | size) > 0xffffU) {
if (size && bytes / size != nmemb)
return NULL;
}
buffer = malloc(bytes);
if (buffer)
(void)memset(buffer, 0, bytes);
return buffer;
}
EFI_STATUS dump_e820(void)
{

40
hypervisor/bsp/uefi/efi/stdlib.h
View File

@ -44,13 +44,6 @@
#ifndef __STDLIB_H__
#define __STDLIB_H__
extern void *malloc(UINTN size);
extern void free(void *buf);
extern void *calloc(UINTN nmemb, UINTN size);
extern EFI_STATUS emalloc(UINTN, UINTN, EFI_PHYSICAL_ADDRESS *);
extern EFI_STATUS __emalloc(UINTN, UINTN, EFI_PHYSICAL_ADDRESS *, EFI_MEMORY_TYPE);
extern void efree(EFI_PHYSICAL_ADDRESS, UINTN);
static inline void memset(void *dstv, char ch, UINTN size)
{
@ -80,39 +73,6 @@ static inline int strlen(const char *str)
return len;
}
static inline char *strstr(const char *haystack, const char *needle)
{
const char *p;
const char *word = NULL;
int len = strlen(needle);
if (!len)
return NULL;
p = haystack;
while (*p) {
word = p;
if (!strncmpa((CHAR8 *)p, (CHAR8 *)needle, len))
break;
p++;
word = NULL;
}
return (char *)word;
}
static inline char *strdup(const char *src)
{
int len;
char *dst;
len = strlen(src);
dst = malloc(len + 1);
if (dst)
memcpy(dst, src, len + 1);
return dst;
}
static inline CHAR16 *strstr_16(CHAR16 *haystack, CHAR16 *needle)
{
CHAR16 *p;