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
@@ -528,7 +532,7 @@ static void set_canary(UNUSED const struct slab_metadata *metadata, UNUSED void
528532 }
529533#endif
530534
531- memcpy ((char * )p + size - canary_size , & metadata -> canary_value , canary_size );
535+ h_memcpy_internal ((char * )p + size - canary_size , & metadata -> canary_value , canary_size );
532536#endif
533537}
534538
@@ -541,7 +545,7 @@ static void check_canary(UNUSED const struct slab_metadata *metadata, UNUSED con
541545#endif
542546
543547 u64 canary_value ;
544- memcpy (& canary_value , (const char * )p + size - canary_size , canary_size );
548+ h_memcpy_internal (& canary_value , (const char * )p + size - canary_size , canary_size );
545549
546550#ifdef HAS_ARM_MTE
547551 if (unlikely (canary_value == 0 )) {
@@ -831,7 +835,7 @@ static inline void deallocate_small(void *p, const size_t *expected_size) {
831835#endif
832836
833837 if (ZERO_ON_FREE && !skip_zero ) {
834- memset (p , 0 , size - canary_size );
838+ h_memset_internal (p , 0 , size - canary_size );
835839 }
836840 }
837841
@@ -1502,7 +1506,7 @@ EXPORT void *h_calloc(size_t nmemb, size_t size) {
15021506 total_size = adjust_size_for_canary (total_size );
15031507 void * p = alloc (total_size );
15041508 if (!ZERO_ON_FREE && likely (p != NULL ) && total_size && total_size <= max_slab_size_class ) {
1505- memset (p , 0 , total_size - canary_size );
1509+ h_memset_internal (p , 0 , total_size - canary_size );
15061510 }
15071511#ifdef HAS_ARM_MTE
15081512 // use an assert instead of adding a conditional to memset() above (freed memory is always
@@ -1625,7 +1629,7 @@ EXPORT void *h_realloc(void *old, size_t size) {
16251629 mutex_unlock (& ra -> lock );
16261630
16271631 if (memory_remap_fixed (old , old_size , new , size )) {
1628- memcpy (new , old , copy_size );
1632+ h_memcpy_internal (new , old , copy_size );
16291633 deallocate_pages (old , old_size , old_guard_size );
16301634 } else {
16311635 memory_unmap ((char * )old - old_guard_size , old_guard_size );
@@ -1647,7 +1651,7 @@ EXPORT void *h_realloc(void *old, size_t size) {
16471651 if (copy_size > 0 && copy_size <= max_slab_size_class ) {
16481652 copy_size -= canary_size ;
16491653 }
1650- memcpy (new , old_orig , copy_size );
1654+ h_memcpy_internal (new , old_orig , copy_size );
16511655 if (old_in_slab_region ) {
16521656 deallocate_small (old , NULL );
16531657 } else {
@@ -1875,6 +1879,133 @@ EXPORT size_t h_malloc_object_size_fast(const void *p) {
18751879 return SIZE_MAX ;
18761880}
18771881
1882+ #if CONFIG_BLOCK_OPS_CHECK_SIZE && !defined(HAS_ARM_MTE )
1883+ EXPORT void * memcpy (void * restrict dst , const void * restrict src , size_t len ) {
1884+ if (unlikely (dst == src || len == 0 )) {
1885+ return dst ;
1886+ }
1887+ if (unlikely (dst < (src + len ) && (dst + len ) > src )) {
1888+ fatal_error ("memcpy overlap" );
1889+ }
1890+ if (unlikely (len > malloc_object_size (src ))) {
1891+ fatal_error ("memcpy read overflow" );
1892+ }
1893+ if (unlikely (len > malloc_object_size (dst ))) {
1894+ fatal_error ("memcpy buffer overflow" );
1895+ }
1896+ return musl_memcpy (dst , src , len );
1897+ }
1898+
1899+ EXPORT void * memccpy (void * restrict dst , const void * restrict src , int value , size_t len ) {
1900+ if (unlikely (dst == src || len == 0 )) {
1901+ return dst ;
1902+ }
1903+ if (unlikely (dst < (src + len ) && (dst + len ) > src )) {
1904+ fatal_error ("memccpy overlap" );
1905+ }
1906+ if (unlikely (len > malloc_object_size (src ) && value != 0 )) {
1907+ fatal_error ("memccpy read overflow" );
1908+ }
1909+ if (unlikely (len > malloc_object_size (dst ))) {
1910+ fatal_error ("memccpy buffer overflow" );
1911+ }
1912+ return musl_memccpy (dst , src , value , len );
1913+ }
1914+
1915+ EXPORT void * memmove (void * dst , const void * src , size_t len ) {
1916+ if (unlikely (dst == src || len == 0 )) {
1917+ return dst ;
1918+ }
1919+ if (unlikely (len > malloc_object_size (src ))) {
1920+ fatal_error ("memmove read overflow" );
1921+ }
1922+ if (unlikely (len > malloc_object_size (dst ))) {
1923+ fatal_error ("memmove buffer overflow" );
1924+ }
1925+ return musl_memmove (dst , src , len );
1926+ }
1927+
1928+ EXPORT void * mempcpy (void * restrict dst , const void * restrict src , size_t len ) {
1929+ return memcpy (dst , src , len ) + len ;
1930+ }
1931+
1932+ EXPORT void * memset (void * dst , int value , size_t len ) {
1933+ if (unlikely (len == 0 )) {
1934+ return dst ;
1935+ }
1936+ if (unlikely (len > malloc_object_size (dst ))) {
1937+ fatal_error ("memset buffer overflow" );
1938+ }
1939+ return musl_memset (dst , value , len );
1940+ }
1941+
1942+ EXPORT void bcopy (const void * src , void * dst , size_t len ) {
1943+ memmove (dst , src , len );
1944+ }
1945+
1946+ EXPORT void swab (const void * restrict src , void * restrict dst , ssize_t len ) {
1947+ if (unlikely (len <= 0 )) {
1948+ return ;
1949+ }
1950+ size_t length = len ;
1951+ if (unlikely (dst < (src + length ) && (dst + length ) > src )) {
1952+ fatal_error ("swab overlap" );
1953+ }
1954+ if (unlikely (length > malloc_object_size (src ))) {
1955+ fatal_error ("swab read overflow" );
1956+ }
1957+ if (unlikely (length > malloc_object_size (dst ))) {
1958+ fatal_error ("swab buffer overflow" );
1959+ }
1960+ return musl_swab (src , dst , len );
1961+ }
1962+
1963+ EXPORT wchar_t * wmemcpy (wchar_t * restrict dst , const wchar_t * restrict src , size_t len ) {
1964+ if (unlikely (dst == src || len == 0 )) {
1965+ return dst ;
1966+ }
1967+ if (unlikely (dst < (src + len ) && (dst + len ) > src )) {
1968+ fatal_error ("wmemcpy overlap" );
1969+ }
1970+ size_t lenAdj = len * sizeof (wchar_t );
1971+ if (unlikely (lenAdj > malloc_object_size (src ))) {
1972+ fatal_error ("wmemcpy read overflow" );
1973+ }
1974+ if (unlikely (lenAdj > malloc_object_size (dst ))) {
1975+ fatal_error ("wmemcpy buffer overflow" );
1976+ }
1977+ return (wchar_t * )musl_memcpy ((char * )dst , (const char * )src , lenAdj );
1978+ }
1979+
1980+ EXPORT wchar_t * wmemmove (wchar_t * dst , const wchar_t * src , size_t len ) {
1981+ if (unlikely (dst == src || len == 0 )) {
1982+ return dst ;
1983+ }
1984+ size_t lenAdj = len * sizeof (wchar_t );
1985+ if (unlikely (lenAdj > malloc_object_size (src ))) {
1986+ fatal_error ("wmemmove read overflow" );
1987+ }
1988+ if (unlikely (lenAdj > malloc_object_size (dst ))) {
1989+ fatal_error ("wmemmove buffer overflow" );
1990+ }
1991+ return (wchar_t * )musl_memmove ((char * )dst , (const char * )src , lenAdj );
1992+ }
1993+
1994+ EXPORT wchar_t * wmempcpy (wchar_t * restrict dst , const wchar_t * restrict src , size_t len ) {
1995+ return wmemcpy (dst , src , len ) + len ;
1996+ }
1997+
1998+ EXPORT wchar_t * wmemset (wchar_t * dst , wchar_t value , size_t len ) {
1999+ if (unlikely (len == 0 )) {
2000+ return dst ;
2001+ }
2002+ if (unlikely ((len * sizeof (wchar_t )) > malloc_object_size (dst ))) {
2003+ fatal_error ("wmemset buffer overflow" );
2004+ }
2005+ return musl_wmemset (dst , value , len );
2006+ }
2007+ #endif /* CONFIG_BLOCK_OPS_CHECK_SIZE && !defined(HAS_ARM_MTE) */
2008+
18782009EXPORT int h_mallopt (UNUSED int param , UNUSED int value ) {
18792010#ifdef __ANDROID__
18802011 if (param == M_PURGE ) {
0 commit comments