diff --git a/include/mimalloc-internal.h b/include/mimalloc-internal.h
index 97abb4a3..ebef9a23 100644
--- a/include/mimalloc-internal.h
+++ b/include/mimalloc-internal.h
@@ -81,7 +81,7 @@ void       _mi_stats_done(mi_stats_t* stats);
 void*       _mi_page_malloc(mi_heap_t* heap, mi_page_t* page, size_t size) mi_attr_noexcept;  // called from `_mi_malloc_generic`
 void*       _mi_heap_malloc_zero(mi_heap_t* heap, size_t size, bool zero);
 void*       _mi_realloc_zero(void* p, size_t size, bool zero);
-mi_block_t* _mi_page_ptr_unalign(const mi_segment_t* segment, const mi_page_t* page, void* p);
+mi_block_t* _mi_page_ptr_unalign(const mi_segment_t* segment, const mi_page_t* page, const void* p);
 void        _mi_free_delayed_block(mi_block_t* block);
 
 #if MI_DEBUG>1
diff --git a/include/mimalloc.h b/include/mimalloc.h
index 51f7ce1b..f56a81e9 100644
--- a/include/mimalloc.h
+++ b/include/mimalloc.h
@@ -104,7 +104,7 @@ mi_decl_export mi_decl_allocator void* mi_reallocf(void* p, size_t newsize)
 mi_decl_export mi_decl_allocator void* mi_rezalloc(void* p, size_t newsize)             mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size(2);
 mi_decl_export mi_decl_allocator void* mi_recalloc(void* p, size_t count, size_t size)  mi_attr_noexcept mi_attr_malloc mi_attr_alloc_size2(2,3);
 
-mi_decl_export size_t mi_usable_size(void* p)   mi_attr_noexcept;
+mi_decl_export size_t mi_usable_size(const void* p)   mi_attr_noexcept;
 mi_decl_export size_t mi_good_size(size_t size) mi_attr_noexcept;
 
 mi_decl_export void mi_collect(bool force)    mi_attr_noexcept;
@@ -117,7 +117,7 @@ mi_decl_export void mi_thread_done(void)      mi_attr_noexcept;
 mi_decl_export void mi_thread_stats_print(FILE* out) mi_attr_noexcept;
 
 typedef void (mi_deferred_free_fun)(bool force, unsigned long long heartbeat);
-mi_decl_export void mi_register_deferred_free(mi_deferred_free_fun* deferred_free) mi_attr_noexcept;
+mi_decl_export void mi_register_deferred_free(const mi_deferred_free_fun* deferred_free) mi_attr_noexcept;
 
 
 // ------------------------------------------------------
@@ -186,9 +186,9 @@ typedef struct mi_heap_area_s {
   size_t block_size;  // size in bytes of each block
 } mi_heap_area_t;
 
-typedef bool (mi_block_visit_fun)(const mi_heap_t* heap, const mi_heap_area_t* area, void* block, size_t block_size, void* arg);
+typedef bool (mi_block_visit_fun)(const mi_heap_t* heap, const mi_heap_area_t* area, void* block, size_t block_size, const void* arg);
 
-mi_decl_export bool mi_heap_visit_blocks(const mi_heap_t* heap, bool visit_all_blocks, mi_block_visit_fun* visitor, void* arg);
+mi_decl_export bool mi_heap_visit_blocks(const mi_heap_t* heap, bool visit_all_blocks, mi_block_visit_fun* visitor, const void* arg);
 
 // ------------------------------------------------------
 // Convenience
diff --git a/src/alloc.c b/src/alloc.c
index e8543a96..91dccd1c 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -177,7 +177,7 @@ static inline void _mi_free_block(mi_page_t* page, bool local, mi_block_t* block
 
 
 // Adjust a block that was allocated aligned, to the actual start of the block in the page.
-mi_block_t* _mi_page_ptr_unalign(const mi_segment_t* segment, const mi_page_t* page, void* p) {
+mi_block_t* _mi_page_ptr_unalign(const mi_segment_t* segment, const mi_page_t* page, const void* p) {
   mi_assert_internal(page!=NULL && p!=NULL);
   size_t diff   = (uint8_t*)p - _mi_page_start(segment, page, NULL);
   size_t adjust = (diff % page->block_size);
@@ -256,7 +256,7 @@ void _mi_free_delayed_block(mi_block_t* block) {
 }
 
 // Bytes available in a block
-size_t mi_usable_size(void* p) mi_attr_noexcept {
+size_t mi_usable_size(const void* p) mi_attr_noexcept {
   if (p==NULL) return 0;
   const mi_segment_t* segment = _mi_ptr_segment(p);
   const mi_page_t* page = _mi_segment_page_of(segment,p);
diff --git a/src/heap.c b/src/heap.c
index f474b1a0..4e4cb039 100644
--- a/src/heap.c
+++ b/src/heap.c
@@ -17,10 +17,10 @@ terms of the MIT license. A copy of the license can be found in the file
 ----------------------------------------------------------- */
 
 // return `true` if ok, `false` to break
-typedef bool (heap_page_visitor_fun)(mi_heap_t* heap, mi_page_queue_t* pq, mi_page_t* page, void* arg1, void* arg2);
+typedef bool (heap_page_visitor_fun)(mi_heap_t* heap, mi_page_queue_t* pq, mi_page_t* page, const void* arg1, const void* arg2);
 
 // Visit all pages in a heap; returns `false` if break was called.
-static bool mi_heap_visit_pages(mi_heap_t* heap, heap_page_visitor_fun* fn, void* arg1, void* arg2)
+static bool mi_heap_visit_pages(mi_heap_t* heap, heap_page_visitor_fun* fn, const void* arg1, const void* arg2)
 {
   if (heap==NULL || heap->page_count==0) return 0;
 
@@ -46,7 +46,7 @@ static bool mi_heap_visit_pages(mi_heap_t* heap, heap_page_visitor_fun* fn, void
 
 
 #if MI_DEBUG>1
-static bool _mi_heap_page_is_valid(mi_heap_t* heap, mi_page_queue_t* pq, mi_page_t* page, void* arg1, void* arg2) {
+static bool _mi_heap_page_is_valid(mi_heap_t* heap, mi_page_queue_t* pq, mi_page_t* page, const void* arg1, const void* arg2) {
   UNUSED(arg1);
   UNUSED(arg2);
   UNUSED(pq);
@@ -81,7 +81,7 @@ typedef enum mi_collect_e {
 } mi_collect_t;
 
 
-static bool mi_heap_page_collect(mi_heap_t* heap, mi_page_queue_t* pq, mi_page_t* page, void* arg_collect, void* arg2 ) {
+static bool mi_heap_page_collect(mi_heap_t* heap, mi_page_queue_t* pq, mi_page_t* page, const void* arg_collect, const void* arg2 ) {
   UNUSED(arg2);
   UNUSED(heap);
   mi_collect_t collect = (mi_collect_t)arg_collect;
@@ -221,7 +221,7 @@ static void mi_heap_free(mi_heap_t* heap) {
   Heap destroy
 ----------------------------------------------------------- */
 
-static bool _mi_heap_page_destroy(mi_heap_t* heap, mi_page_queue_t* pq, mi_page_t* page, void* arg1, void* arg2) {
+static bool _mi_heap_page_destroy(mi_heap_t* heap, mi_page_queue_t* pq, mi_page_t* page, const void* arg1, const void* arg2) {
   UNUSED(arg1);
   UNUSED(arg2);
   UNUSED(heap);
@@ -362,7 +362,7 @@ bool mi_heap_contains_block(mi_heap_t* heap, const void* p) {
 }
 
 
-static bool mi_heap_page_check_owned(mi_heap_t* heap, mi_page_queue_t* pq, mi_page_t* page, void* p, void* vfound) {
+static bool mi_heap_page_check_owned(mi_heap_t* heap, mi_page_queue_t* pq, mi_page_t* page, const void* p, const void* vfound) {
   UNUSED(heap);
   UNUSED(pq);
   bool* found = (bool*)vfound;
@@ -398,7 +398,7 @@ typedef struct mi_heap_area_ex_s {
   mi_page_t*     page;
 } mi_heap_area_ex_t;
 
-static bool mi_heap_area_visit_blocks(const mi_heap_area_ex_t* xarea, mi_block_visit_fun* visitor, void* arg) {
+static bool mi_heap_area_visit_blocks(const mi_heap_area_ex_t* xarea, mi_block_visit_fun* visitor, const void* arg) {
   mi_assert(xarea != NULL);
   if (xarea==NULL) return true;
   const mi_heap_area_t* area = &xarea->area;
@@ -457,10 +457,10 @@ static bool mi_heap_area_visit_blocks(const mi_heap_area_ex_t* xarea, mi_block_v
   return true;
 }
 
-typedef bool (mi_heap_area_visit_fun)(const mi_heap_t* heap, const mi_heap_area_ex_t* area, void* arg);
+typedef bool (mi_heap_area_visit_fun)(const mi_heap_t* heap, mi_heap_area_ex_t* area, const void* arg);
 
 
-static bool mi_heap_visit_areas_page(mi_heap_t* heap, mi_page_queue_t* pq, mi_page_t* page, void* vfun, void* arg) {
+static bool mi_heap_visit_areas_page(mi_heap_t* heap, mi_page_queue_t* pq, mi_page_t* page, const void* vfun, const void* arg) {
   UNUSED(heap);
   UNUSED(pq);
   mi_heap_area_visit_fun* fun = (mi_heap_area_visit_fun*)vfun;
@@ -475,7 +475,7 @@ static bool mi_heap_visit_areas_page(mi_heap_t* heap, mi_page_queue_t* pq, mi_pa
 }
 
 // Visit all heap pages as areas
-static bool mi_heap_visit_areas(const mi_heap_t* heap, mi_heap_area_visit_fun* visitor, void* arg) {
+static bool mi_heap_visit_areas(const mi_heap_t* heap, mi_heap_area_visit_fun* visitor, const void* arg) {
   if (visitor == NULL) return false;
   return mi_heap_visit_pages((mi_heap_t*)heap, &mi_heap_visit_areas_page, visitor, arg);
 }
@@ -483,11 +483,11 @@ static bool mi_heap_visit_areas(const mi_heap_t* heap, mi_heap_area_visit_fun* v
 // Just to pass arguments
 typedef struct mi_visit_blocks_args_s {
   bool  visit_blocks;
-  mi_block_visit_fun* visitor;
-  void* arg;
+   mi_block_visit_fun* visitor;
+  const void* arg;
 } mi_visit_blocks_args_t;
 
-static bool mi_heap_area_visitor(const mi_heap_t* heap, const mi_heap_area_ex_t* xarea, void* arg) {
+static bool mi_heap_area_visitor(const mi_heap_t* heap, mi_heap_area_ex_t* xarea, const void* arg) {
   mi_visit_blocks_args_t* args = (mi_visit_blocks_args_t*)arg;
   if (!args->visitor(heap, &xarea->area, NULL, xarea->area.block_size, arg)) return false;
   if (args->visit_blocks) {
@@ -499,8 +499,8 @@ static bool mi_heap_area_visitor(const mi_heap_t* heap, const mi_heap_area_ex_t*
 }
 
 // Visit all blocks in a heap
-bool mi_heap_visit_blocks(const mi_heap_t* heap, bool visit_blocks, mi_block_visit_fun* visitor, void* arg) {
-  mi_visit_blocks_args_t args = { visit_blocks, visitor, arg };
+bool mi_heap_visit_blocks(const mi_heap_t* heap, bool visit_blocks, mi_block_visit_fun* visitor, const void* arg) {
+  const mi_visit_blocks_args_t args = { visit_blocks, visitor, arg };
   return mi_heap_visit_areas(heap, &mi_heap_area_visitor, &args);
 }
 
diff --git a/src/page.c b/src/page.c
index 85b810e1..a672c2da 100644
--- a/src/page.c
+++ b/src/page.c
@@ -642,7 +642,7 @@ static inline mi_page_t* mi_find_free_page(mi_heap_t* heap, size_t size) {
   a certain number of allocations.
 ----------------------------------------------------------- */
 
-static mi_deferred_free_fun* deferred_free = NULL;
+static const mi_deferred_free_fun* deferred_free = NULL;
 
 void _mi_deferred_free(mi_heap_t* heap, bool force) {
   heap->tld->heartbeat++;
@@ -651,7 +651,7 @@ void _mi_deferred_free(mi_heap_t* heap, bool force) {
   }
 }
 
-void mi_register_deferred_free(mi_deferred_free_fun* fn) mi_attr_noexcept {
+void mi_register_deferred_free(const mi_deferred_free_fun* fn) mi_attr_noexcept {
   deferred_free = fn;
 }