vasilito/RedBear-OS
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Alloc functions cleanup

Browse Source
This commit is contained in:
Peter Limkilde Svendsen
2019-07-01 11:02:10 +00:00
committed by jD91mZM2
parent b43e1bf83b
commit 02e26006e7
2 changed files with 63 additions and 23 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/header/stdlib/mod.rs
+12 -16
View File
@@ -92,7 +92,7 @@ pub unsafe extern "C" fn aligned_alloc(alignment: size_t, size: size_t) -> *mut
* difference between aligned_alloc() and memalign(). */
memalign(alignment, size)
} else {
platform::errno = errno::EINVAL;
platform::errno = EINVAL;
ptr::null_mut()
}
}
@@ -199,8 +199,7 @@ pub unsafe extern "C" fn bsearch(
#[no_mangle]
pub unsafe extern "C" fn calloc(nelem: size_t, elsize: size_t) -> *mut c_void {
//Handle possible integer overflow in size calculation
let size_result = nelem.checked_mul(elsize);
match size_result {
match nelem.checked_mul(elsize) {
Some(size) => {
/* If allocation fails here, errno setting will be handled
* by malloc() */
@@ -212,7 +211,7 @@ pub unsafe extern "C" fn calloc(nelem: size_t, elsize: size_t) -> *mut c_void {
}
None => {
// For overflowing multiplication, we have to set errno here
platform::errno = errno::ENOMEM;
platform::errno = ENOMEM;
ptr::null_mut()
}
}
@@ -463,24 +462,21 @@ pub unsafe extern "C" fn lrand48() -> c_long {
pub unsafe extern "C" fn malloc(size: size_t) -> *mut c_void {
let ptr = platform::alloc(size);
if ptr.is_null() {
platform::errno = errno::ENOMEM;
platform::errno = ENOMEM;
}
ptr
}
#[no_mangle]
pub unsafe extern "C" fn memalign(alignment: size_t, size: size_t) -> *mut c_void {
/* Check if alignment is a (positive) power of two. The second
* expression will never underflow, due to Rust's lazy boolean
* operators. */
if alignment > 0 && (alignment & (alignment - 1)) == 0 {
if alignment.is_power_of_two() {
let ptr = platform::alloc_align(size, alignment);
if ptr.is_null() {
platform::errno = errno::ENOMEM;
platform::errno = ENOMEM;
}
ptr
} else {
platform::errno = errno::EINVAL;
platform::errno = EINVAL;
ptr::null_mut()
}
}
@@ -726,11 +722,11 @@ pub extern "C" fn random() -> c_long {
#[no_mangle]
pub unsafe extern "C" fn realloc(ptr: *mut c_void, size: size_t) -> *mut c_void {
let ptr = platform::realloc(ptr, size);
if ptr.is_null() {
platform::errno = errno::ENOMEM;
let new_ptr = platform::realloc(ptr, size);
if new_ptr.is_null() {
platform::errno = ENOMEM;
}
ptr
new_ptr
}
#[no_mangle]
@@ -1101,7 +1097,7 @@ pub unsafe extern "C" fn valloc(size: size_t) -> *mut c_void {
* EINVAL, hence no call to memalign(). */
let ptr = platform::alloc_align(size, page_size);
if ptr.is_null() {
platform::errno = errno::ENOMEM;
platform::errno = ENOMEM;
}
ptr
}
tests/stdlib/alloc.c
+51 -7
View File
@@ -12,7 +12,7 @@ int main(void) {
size_t sample_realloc_size = sample_alloc_size + 1;
/* ensure values are mapped to variables */
size_t zero = 0;
size_t zero_size = 0;
size_t max_size = SIZE_MAX;
size_t aligned_alloc_alignment = 128;
size_t aligned_alloc_goodsize = 256;
@@ -22,6 +22,14 @@ int main(void) {
int i;
errno = 0;
char * ptr_zerosize_malloc = (char *)malloc(zero_size);
int malloc_zerosize_errno = errno;
printf("malloc (size 0) : %p, errno: %d = %s\n",
ptr_zerosize_malloc, malloc_zerosize_errno,
strerror(malloc_zerosize_errno));
free(ptr_zerosize_malloc);
errno = 0;
char * ptr_malloc = (char *)malloc(sample_alloc_size);
int malloc_errno = errno;
@@ -40,6 +48,14 @@ int main(void) {
strerror(malloc_maxsize_errno));
free(ptr_malloc_maxsize);
errno = 0;
char * ptr_zerosize_calloc = (char *)calloc(zero_size, 1);
int calloc_zerosize_errno = errno;
printf("calloc (size 0) : %p, errno: %d = %s\n",
ptr_zerosize_calloc,
calloc_zerosize_errno, strerror(calloc_zerosize_errno));
free(ptr_zerosize_calloc);
errno = 0;
char * ptr_calloc = (char *)calloc(sample_alloc_size, 1);
int calloc_errno = errno;
@@ -58,6 +74,15 @@ int main(void) {
strerror(calloc_overflow_errno));
free(ptr_calloc_overflow); /* clean up correctly even if overflow is not handled */
char * ptr_realloc_size0 = (char *)malloc(sample_alloc_size);
errno = 0;
ptr_realloc_size0 = (char *)realloc(ptr_realloc_size0, zero_size);
int realloc_size0_errno = errno;
printf("realloc (size 0) : %p, errno: %d = %s\n",
ptr_realloc_size0, realloc_size0_errno,
strerror(realloc_size0_errno));
free(ptr_realloc_size0);
char * ptr_realloc = (char *)malloc(sample_alloc_size);
errno = 0;
ptr_realloc = (char *)realloc(ptr_realloc, sample_realloc_size);
@@ -78,6 +103,14 @@ int main(void) {
strerror(realloc_maxsize_errno));
free(ptr_realloc_maxsize);
errno = 0;
char * ptr_memalign_size0 = (char *)memalign(256, zero_size);
int memalign_size0_errno = errno;
printf("memalign (size 0) : %p, errno: %d = %s\n",
ptr_memalign_size0, memalign_size0_errno,
strerror(memalign_size0_errno));
free(ptr_memalign_size0);
errno = 0;
char * ptr_memalign = (char *)memalign(256, sample_alloc_size);
int memalign_errno = errno;
@@ -130,11 +163,20 @@ int main(void) {
strerror(aligned_alloc_badsize_errno));
free(ptr_aligned_alloc_badsize);
errno = 0;
char * ptr_valloc_size0 = (char *)valloc(zero_size);
int valloc_size0_errno = errno;
printf("valloc (size 0) : %p, errno: %d = %s\n",
ptr_valloc_size0, valloc_size0_errno,
strerror(valloc_size0_errno));
free(ptr_valloc_size0);
errno = 0;
char * ptr_valloc = (char *)valloc(sample_alloc_size);
int valloc_errno = errno;
printf("valloc : %p, errno: %d = %s\n",
ptr_valloc, valloc_errno, strerror(valloc_errno));
free(ptr_valloc);
errno = 0;
char * ptr_valloc_maxsize = (char *)valloc(max_size);
@@ -142,6 +184,7 @@ int main(void) {
printf("valloc (SIZE_MAX) : %p, errno: %d = %s\n",
ptr_valloc_maxsize, valloc_maxsize_errno,
strerror(valloc_maxsize_errno));
free(ptr_valloc_maxsize);
errno = 0;
void * ptr_posix_memalign = NULL;
@@ -156,20 +199,21 @@ int main(void) {
printf(" errno: %d = %s\n",
posix_memalign_errno,
strerror(posix_memalign_errno));
free(ptr_posix_memalign);
errno = 0;
void * ptr_posix_memalign_align0 = NULL;
int posix_memalign_align0_return = posix_memalign(&ptr_posix_memalign_align0, zero, sample_alloc_size);
int posix_memalign_align0_return = posix_memalign(&ptr_posix_memalign_align0, zero_size, sample_alloc_size);
int posix_memalign_align0_errno = errno;
printf("posix_memalign (alignment 0):\n");
printf(" %p, return value: %d = %s,\n",
ptr_posix_memalign_align0,
posix_memalign_align0_return,
strerror(posix_memalign_align0_return));
printf(" errno: %d = %s\n",
posix_memalign_align0_errno,
strerror(posix_memalign_align0_errno));
free(ptr_posix_memalign_align0);
errno = 0;
void * ptr_posix_memalign_nonpow2mul = NULL;
@@ -180,24 +224,24 @@ int main(void) {
ptr_posix_memalign_nonpow2mul,
posix_memalign_nonpow2mul_return,
strerror(posix_memalign_nonpow2mul_return));
printf(" errno: %d = %s\n",
posix_memalign_nonpow2mul_errno,
strerror(posix_memalign_nonpow2mul_errno));
free(ptr_posix_memalign_nonpow2mul);
errno = 0;
void * ptr_posix_memalign_size0 = NULL;
int posix_memalign_size0_return = posix_memalign(&ptr_posix_memalign_size0, pow2_mul_voidptr_size, zero);
int posix_memalign_size0_return = posix_memalign(&ptr_posix_memalign_size0, pow2_mul_voidptr_size, zero_size);
int posix_memalign_size0_errno = errno;
printf("posix_memalign (size 0):\n");
printf(" %p, return value: %d = %s,\n",
ptr_posix_memalign_size0,
posix_memalign_size0_return,
strerror(posix_memalign_size0_return));
printf(" errno: %d = %s\n",
posix_memalign_size0_errno,
strerror(posix_memalign_size0_errno));
free(ptr_posix_memalign_size0);
errno = 0;
void * ptr_posix_memalign_maxsize = NULL;
@@ -208,8 +252,8 @@ int main(void) {
ptr_posix_memalign_maxsize,
posix_memalign_maxsize_return,
strerror(posix_memalign_maxsize_return));
printf(" errno: %d = %s\n",
posix_memalign_maxsize_errno,
strerror(posix_memalign_maxsize_errno));
free(ptr_posix_memalign_maxsize);
}