1515#include "h_malloc.h"
1616#include "memory.h"
1717#include "memtag.h"
18+ #include "musl.h"
1819#include "mutex.h"
1920#include "pages.h"
2021#include "random.h"
@@ -528,7 +529,7 @@ static void set_canary(UNUSED const struct slab_metadata *metadata, UNUSED void
528529 }
529530#endif
530531
531- memcpy ((char * )p + size - canary_size , & metadata -> canary_value , canary_size );
532+ h_memcpy_internal ((char * )p + size - canary_size , & metadata -> canary_value , canary_size );
532533#endif
533534}
534535
@@ -541,7 +542,7 @@ static void check_canary(UNUSED const struct slab_metadata *metadata, UNUSED con
541542#endif
542543
543544 u64 canary_value ;
544- memcpy (& canary_value , (const char * )p + size - canary_size , canary_size );
545+ h_memcpy_internal (& canary_value , (const char * )p + size - canary_size , canary_size );
545546
546547#ifdef HAS_ARM_MTE
547548 if (unlikely (canary_value == 0 )) {
@@ -831,7 +832,7 @@ static inline void deallocate_small(void *p, const size_t *expected_size) {
831832#endif
832833
833834 if (ZERO_ON_FREE && !skip_zero ) {
834- memset (p , 0 , size - canary_size );
835+ h_memset_internal (p , 0 , size - canary_size );
835836 }
836837 }
837838
@@ -1502,7 +1503,7 @@ EXPORT void *h_calloc(size_t nmemb, size_t size) {
15021503 total_size = adjust_size_for_canary (total_size );
15031504 void * p = alloc (total_size );
15041505 if (!ZERO_ON_FREE && likely (p != NULL ) && total_size && total_size <= max_slab_size_class ) {
1505- memset (p , 0 , total_size - canary_size );
1506+ h_memset_internal (p , 0 , total_size - canary_size );
15061507 }
15071508#ifdef HAS_ARM_MTE
15081509 // use an assert instead of adding a conditional to memset() above (freed memory is always
@@ -1624,7 +1625,7 @@ EXPORT void *h_realloc(void *old, size_t size) {
16241625 mutex_unlock (& ra -> lock );
16251626
16261627 if (memory_remap_fixed (old , old_size , new , size )) {
1627- memcpy (new , old , copy_size );
1628+ h_memcpy_internal (new , old , copy_size );
16281629 deallocate_pages (old , old_size , old_guard_size );
16291630 } else {
16301631 memory_unmap ((char * )old - old_guard_size , old_guard_size );
@@ -1646,7 +1647,7 @@ EXPORT void *h_realloc(void *old, size_t size) {
16461647 if (copy_size > 0 && copy_size <= max_slab_size_class ) {
16471648 copy_size -= canary_size ;
16481649 }
1649- memcpy (new , old_orig , copy_size );
1650+ h_memcpy_internal (new , old_orig , copy_size );
16501651 if (old_size <= max_slab_size_class ) {
16511652 deallocate_small (old , NULL );
16521653 } else {
@@ -1874,6 +1875,86 @@ EXPORT size_t h_malloc_object_size_fast(const void *p) {
18741875 return SIZE_MAX ;
18751876}
18761877
1878+ #if CONFIG_BLOCK_OPS_CHECK_SIZE && !defined(HAS_ARM_MTE )
1879+ EXPORT void * memcpy (void * restrict dst , const void * restrict src , size_t len ) {
1880+ if (dst == src || len == 0 ) {
1881+ return dst ;
1882+ }
1883+ if (unlikely (dst < src + len && dst + len > src )) {
1884+ fatal_error ("memcpy overlap" );
1885+ }
1886+ if (unlikely (len > malloc_object_size (src ))) {
1887+ fatal_error ("memcpy read overflow" );
1888+ }
1889+ if (unlikely (len > malloc_object_size (dst ))) {
1890+ fatal_error ("memcpy buffer overflow" );
1891+ }
1892+ return musl_memcpy (dst , src , len );
1893+ }
1894+
1895+ EXPORT void * memmove (void * dst , const void * src , size_t len ) {
1896+ if (dst == src || len == 0 ) {
1897+ return dst ;
1898+ }
1899+ if (unlikely (len > malloc_object_size (src ))) {
1900+ fatal_error ("memmove read overflow" );
1901+ }
1902+ if (unlikely (len > malloc_object_size (dst ))) {
1903+ fatal_error ("memmove buffer overflow" );
1904+ }
1905+ return musl_memmove (dst , src , len );
1906+ }
1907+
1908+ EXPORT void * memset (void * dst , int value , size_t len ) {
1909+ if (len == 0 ) {
1910+ return dst ;
1911+ }
1912+ if (unlikely (len > malloc_object_size (dst ))) {
1913+ fatal_error ("memset buffer overflow" );
1914+ }
1915+ return musl_memset (dst , value , len );
1916+ }
1917+
1918+ EXPORT wchar_t * wmemcpy (wchar_t * restrict dst , const wchar_t * restrict src , size_t len ) {
1919+ if (dst == src || len == 0 ) {
1920+ return dst ;
1921+ }
1922+ if (dst < src + len && dst + len > src ) {
1923+ fatal_error ("wmemcpy overlap" );
1924+ }
1925+ if (len > malloc_object_size (src )) {
1926+ fatal_error ("wmemcpy read overflow" );
1927+ }
1928+ if (len > malloc_object_size (dst )) {
1929+ fatal_error ("wmemcpy buffer overflow" );
1930+ }
1931+ return musl_wmemcpy (dst , src , len );
1932+ }
1933+
1934+ EXPORT wchar_t * wmemmove (wchar_t * dst , const wchar_t * src , size_t len ) {
1935+ if (dst == src || len == 0 ) {
1936+ return dst ;
1937+ }
1938+ if (len > malloc_object_size (src )) {
1939+ fatal_error ("wmemmove read overflow" );
1940+ }
1941+ if (len > malloc_object_size (dst )) {
1942+ fatal_error ("wmemmove buffer overflow" );
1943+ }
1944+ return musl_wmemmove (dst , src , len );
1945+ }
1946+
1947+ EXPORT wchar_t * wmemset (wchar_t * dst , wchar_t value , size_t len ) {
1948+ if (len == 0 ) {
1949+ return dst ;
1950+ }
1951+ if (len > malloc_object_size (dst )) {
1952+ fatal_error ("wmemset buffer overflow" );
1953+ }
1954+ return musl_wmemset (dst , value , len );
1955+ }
1956+ #endif
1957+
18771958EXPORT int h_mallopt (UNUSED int param , UNUSED int value ) {
18781959#ifdef __ANDROID__
18791960 if (param == M_PURGE ) {
0 commit comments