2020#include "random.h"
2121#include "util.h"
2222
23+ #if CONFIG_BLOCK_OPS_CHECK_SIZE && !defined(HAS_ARM_MTE )
24+ #include "musl.h"
25+ #endif
26+
2327#ifdef USE_PKEY
2428#include <sys/mman.h>
2529#endif
@@ -537,7 +541,7 @@ static void set_canary(UNUSED const struct slab_metadata *metadata, UNUSED void
537541 }
538542#endif
539543
540- memcpy ((char * )p + size - canary_size , & metadata -> canary_value , canary_size );
544+ h_memcpy_internal ((char * )p + size - canary_size , & metadata -> canary_value , canary_size );
541545#endif
542546}
543547
@@ -550,7 +554,7 @@ static void check_canary(UNUSED const struct slab_metadata *metadata, UNUSED con
550554#endif
551555
552556 u64 canary_value ;
553- memcpy (& canary_value , (const char * )p + size - canary_size , canary_size );
557+ h_memcpy_internal (& canary_value , (const char * )p + size - canary_size , canary_size );
554558
555559#ifdef HAS_ARM_MTE
556560 if (unlikely (canary_value == 0 )) {
@@ -837,7 +841,7 @@ static inline void deallocate_small(void *p, const size_t *expected_size) {
837841#endif
838842
839843 if (ZERO_ON_FREE && !skip_zero ) {
840- memset (p , 0 , size - canary_size );
844+ h_memset_internal (p , 0 , size - canary_size );
841845 }
842846 }
843847
@@ -1513,7 +1517,7 @@ EXPORT void *h_calloc(size_t nmemb, size_t size) {
15131517 total_size = adjust_size_for_canary (total_size );
15141518 void * p = alloc (total_size );
15151519 if (!ZERO_ON_FREE && likely (p != NULL ) && total_size && total_size <= max_slab_size_class ) {
1516- memset (p , 0 , total_size - canary_size );
1520+ h_memset_internal (p , 0 , total_size - canary_size );
15171521 }
15181522#ifdef HAS_ARM_MTE
15191523 // use an assert instead of adding a conditional to memset() above (freed memory is always
@@ -1636,7 +1640,7 @@ EXPORT void *h_realloc(void *old, size_t size) {
16361640 mutex_unlock (& ra -> lock );
16371641
16381642 if (memory_remap_fixed (old , old_size , new , size )) {
1639- memcpy (new , old , copy_size );
1643+ h_memcpy_internal (new , old , copy_size );
16401644 deallocate_pages (old , old_size , old_guard_size );
16411645 } else {
16421646 memory_unmap ((char * )old - old_guard_size , old_guard_size );
@@ -1658,7 +1662,7 @@ EXPORT void *h_realloc(void *old, size_t size) {
16581662 if (copy_size > 0 && copy_size <= max_slab_size_class ) {
16591663 copy_size -= canary_size ;
16601664 }
1661- memcpy (new , old_orig , copy_size );
1665+ h_memcpy_internal (new , old_orig , copy_size );
16621666 if (old_in_slab_region ) {
16631667 deallocate_small (old , NULL );
16641668 } else {
@@ -1882,6 +1886,133 @@ EXPORT size_t h_malloc_object_size_fast(const void *p) {
18821886 return SIZE_MAX ;
18831887}
18841888
1889+ #if CONFIG_BLOCK_OPS_CHECK_SIZE && !defined(HAS_ARM_MTE )
1890+ EXPORT void * memcpy (void * restrict dst , const void * restrict src , size_t len ) {
1891+ if (unlikely (dst == src || len == 0 )) {
1892+ return dst ;
1893+ }
1894+ if (unlikely (dst < (src + len ) && (dst + len ) > src )) {
1895+ fatal_error ("memcpy overlap" );
1896+ }
1897+ if (unlikely (len > malloc_object_size (src ))) {
1898+ fatal_error ("memcpy read overflow" );
1899+ }
1900+ if (unlikely (len > malloc_object_size (dst ))) {
1901+ fatal_error ("memcpy buffer overflow" );
1902+ }
1903+ return musl_memcpy (dst , src , len );
1904+ }
1905+
1906+ EXPORT void * memccpy (void * restrict dst , const void * restrict src , int value , size_t len ) {
1907+ if (unlikely (dst == src || len == 0 )) {
1908+ return dst ;
1909+ }
1910+ if (unlikely (dst < (src + len ) && (dst + len ) > src )) {
1911+ fatal_error ("memccpy overlap" );
1912+ }
1913+ if (unlikely (len > malloc_object_size (src ) && value != 0 )) {
1914+ fatal_error ("memccpy read overflow" );
1915+ }
1916+ if (unlikely (len > malloc_object_size (dst ))) {
1917+ fatal_error ("memccpy buffer overflow" );
1918+ }
1919+ return musl_memccpy (dst , src , value , len );
1920+ }
1921+
1922+ EXPORT void * memmove (void * dst , const void * src , size_t len ) {
1923+ if (unlikely (dst == src || len == 0 )) {
1924+ return dst ;
1925+ }
1926+ if (unlikely (len > malloc_object_size (src ))) {
1927+ fatal_error ("memmove read overflow" );
1928+ }
1929+ if (unlikely (len > malloc_object_size (dst ))) {
1930+ fatal_error ("memmove buffer overflow" );
1931+ }
1932+ return musl_memmove (dst , src , len );
1933+ }
1934+
1935+ EXPORT void * mempcpy (void * restrict dst , const void * restrict src , size_t len ) {
1936+ return memcpy (dst , src , len ) + len ;
1937+ }
1938+
1939+ EXPORT void * memset (void * dst , int value , size_t len ) {
1940+ if (unlikely (len == 0 )) {
1941+ return dst ;
1942+ }
1943+ if (unlikely (len > malloc_object_size (dst ))) {
1944+ fatal_error ("memset buffer overflow" );
1945+ }
1946+ return musl_memset (dst , value , len );
1947+ }
1948+
1949+ EXPORT void bcopy (const void * src , void * dst , size_t len ) {
1950+ memmove (dst , src , len );
1951+ }
1952+
1953+ EXPORT void swab (const void * restrict src , void * restrict dst , ssize_t len ) {
1954+ if (unlikely (len <= 0 )) {
1955+ return ;
1956+ }
1957+ size_t length = len ;
1958+ if (unlikely (dst < (src + length ) && (dst + length ) > src )) {
1959+ fatal_error ("swab overlap" );
1960+ }
1961+ if (unlikely (length > malloc_object_size (src ))) {
1962+ fatal_error ("swab read overflow" );
1963+ }
1964+ if (unlikely (length > malloc_object_size (dst ))) {
1965+ fatal_error ("swab buffer overflow" );
1966+ }
1967+ return musl_swab (src , dst , len );
1968+ }
1969+
1970+ EXPORT wchar_t * wmemcpy (wchar_t * restrict dst , const wchar_t * restrict src , size_t len ) {
1971+ if (unlikely (dst == src || len == 0 )) {
1972+ return dst ;
1973+ }
1974+ if (unlikely (dst < (src + len ) && (dst + len ) > src )) {
1975+ fatal_error ("wmemcpy overlap" );
1976+ }
1977+ size_t lenAdj = len * sizeof (wchar_t );
1978+ if (unlikely (lenAdj > malloc_object_size (src ))) {
1979+ fatal_error ("wmemcpy read overflow" );
1980+ }
1981+ if (unlikely (lenAdj > malloc_object_size (dst ))) {
1982+ fatal_error ("wmemcpy buffer overflow" );
1983+ }
1984+ return (wchar_t * )musl_memcpy ((char * )dst , (const char * )src , lenAdj );
1985+ }
1986+
1987+ EXPORT wchar_t * wmemmove (wchar_t * dst , const wchar_t * src , size_t len ) {
1988+ if (unlikely (dst == src || len == 0 )) {
1989+ return dst ;
1990+ }
1991+ size_t lenAdj = len * sizeof (wchar_t );
1992+ if (unlikely (lenAdj > malloc_object_size (src ))) {
1993+ fatal_error ("wmemmove read overflow" );
1994+ }
1995+ if (unlikely (lenAdj > malloc_object_size (dst ))) {
1996+ fatal_error ("wmemmove buffer overflow" );
1997+ }
1998+ return (wchar_t * )musl_memmove ((char * )dst , (const char * )src , lenAdj );
1999+ }
2000+
2001+ EXPORT wchar_t * wmempcpy (wchar_t * restrict dst , const wchar_t * restrict src , size_t len ) {
2002+ return wmemcpy (dst , src , len ) + len ;
2003+ }
2004+
2005+ EXPORT wchar_t * wmemset (wchar_t * dst , wchar_t value , size_t len ) {
2006+ if (unlikely (len == 0 )) {
2007+ return dst ;
2008+ }
2009+ if (unlikely ((len * sizeof (wchar_t )) > malloc_object_size (dst ))) {
2010+ fatal_error ("wmemset buffer overflow" );
2011+ }
2012+ return musl_wmemset (dst , value , len );
2013+ }
2014+ #endif /* CONFIG_BLOCK_OPS_CHECK_SIZE && !defined(HAS_ARM_MTE) */
2015+
18852016EXPORT int h_mallopt (UNUSED int param , UNUSED int value ) {
18862017#ifdef __ANDROID__
18872018 if (param == M_PURGE ) {
0 commit comments