Add malloc_info, malloc_stats_print, mallinfo2, malloc_iterate, malloc_enable,...

Add malloc_info, malloc_stats_print, mallinfo2, malloc_iterate, malloc_enable, malloc_disable, malloc_backtrace, mallopt to musl memory allocator
Signed-off-by: NMaxim Polyakov <polyakov.maksim@huawei.com>

libc-test/src/functional/BUILD.gn

 import("../../test_template.gni")
 import("test_src_functional.gni")
 
+if (is_standard_system) {
+  functional_list += malloc_stats_list
+}
+
 foreach(s, functional_list) {
   test_unittest(s) {
     target_dir = "functional"

libc-test/src/functional/test-iterate.c

+/*
+ * Copyright (C) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#include <stdio.h>
+#include <malloc.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include <stdint.h>
+#include <memory.h>
+
+#include "test-malloc-api-common.h"
+
+#define BARRIER_HEIGHT 2
+#define ALLOCATIONS_NUMBER 8
+#define MIN(x, y) (((x) < (y)) ? (x) : (y))
+
+typedef struct iterate_arg_s {
+	uintptr_t allocs[ALLOCATIONS_NUMBER];
+	size_t allocs_reported_number[ALLOCATIONS_NUMBER];
+	size_t allocs_actual_sizes[ALLOCATIONS_NUMBER];
+	size_t reported_sizes[ALLOCATIONS_NUMBER];
+} iterate_arg_t;
+
+typedef struct {
+	uintptr_t *base;
+	size_t size;
+} allocations_info_t;
+
+static const size_t allocs_sizes[ALLOCATIONS_NUMBER] = {
+	8,
+	2 * 1024,
+	64 * 1024,
+	512 * 1024,
+	2 * 1024 * 1024,
+	8 * 1024 * 1024,
+	16 * 1024 * 1024,
+	32 * 1024 * 1024
+};
+
+void iterate_callback(void *base, size_t size, void *data)
+{
+	iterate_arg_t *iterate_arg = (iterate_arg_t *) data;
+	uintptr_t end;
+	if (__builtin_add_overflow((uintptr_t) base, size, &end)) {
+		return;
+	}
+
+	for (size_t i = 0; i < ALLOCATIONS_NUMBER; ++i) {
+		if (iterate_arg->allocs[i] >= (uintptr_t) base && iterate_arg->allocs[i] < end) {
+			iterate_arg->allocs_reported_number[i]++;
+			uintptr_t max_size = end - iterate_arg->allocs[i];
+			iterate_arg->reported_sizes[i] = MIN(size, max_size);
+		}
+	}
+}
+
+void fill_allocations_info(const iterate_arg_t *iterate_arg, allocations_info_t *allocations_info)
+{
+	size_t min_idx, max_idx;
+	uintptr_t min_val = UINTPTR_MAX, max_val = 0;
+
+	const uintptr_t *allocs = iterate_arg->allocs;
+
+	for (size_t i = 0; i < ALLOCATIONS_NUMBER; ++i) {
+		if (allocs[i] > max_val) {
+			max_val = allocs[i];
+			max_idx = i;
+		}
+		if (allocs[i] < min_val) {
+			min_val = allocs[i];
+			min_idx = i;
+		}
+	}
+
+	allocations_info->base = (void *) allocs[min_idx];
+	allocations_info->size = allocs[max_idx] - allocs[min_idx] + allocs_sizes[max_idx];
+}
+
+void make_allocations(iterate_arg_t *iterate_arg)
+{
+	uintptr_t *allocs = iterate_arg->allocs;
+	size_t *allocs_actual_sizes = iterate_arg->allocs_actual_sizes;
+
+	for (size_t i = 0; i < ALLOCATIONS_NUMBER; ++i) {
+		allocs[i] = (uintptr_t) malloc(allocs_sizes[i]);
+		allocs_actual_sizes[i] = malloc_usable_size((void *) allocs[i]);
+	}
+}
+
+void free_allocations(iterate_arg_t *iterate_arg)
+{
+	uintptr_t *allocs = iterate_arg->allocs;
+
+	for (size_t i = 0; i < ALLOCATIONS_NUMBER; ++i) {
+		free((void *) allocs[i]);
+	}
+}
+
+int iterate_wrapper(iterate_arg_t *iterate_arg)
+{
+	int ret = 0;
+	allocations_info_t allocations_info;
+	fill_allocations_info(iterate_arg, &allocations_info);
+	malloc_iterate(allocations_info.base, allocations_info.size, iterate_callback, iterate_arg);
+
+	for (size_t i = 0; i < ALLOCATIONS_NUMBER; ++i) {
+		if (iterate_arg->allocs_reported_number[i] != 1) {
+			ret = -1;
+		}
+	}
+	return ret;
+}
+
+pthread_barrier_t routine_allocated;
+pthread_barrier_t routine_iterated;
+
+void *allocate_routine(void *vargp)
+{
+	iterate_arg_t *iterate_arg = (iterate_arg_t *) vargp;
+	make_allocations(iterate_arg);
+	pthread_barrier_wait(&routine_allocated);
+	pthread_barrier_wait(&routine_iterated);
+	return NULL;
+}
+
+void *abandoned_allocate_routine(void *vargp)
+{
+	iterate_arg_t *iterate_arg = (iterate_arg_t *) vargp;
+	make_allocations(iterate_arg);
+	return NULL;
+}
+
+int test_iterate_main_thread(void)
+{
+	int ret;
+	iterate_arg_t iterate_arg = {{0}, {0}, {0}, {0}};
+	make_allocations(&iterate_arg);
+	ret = iterate_wrapper(&iterate_arg);
+	free_allocations(&iterate_arg);
+	return ret;
+}
+
+int test_iterate_another_thread(void)
+{
+	int ret;
+	iterate_arg_t iterate_arg_routine = {{0}, {0}, {0}, {0}};
+	pthread_barrier_init(&routine_allocated, NULL, BARRIER_HEIGHT);
+	pthread_barrier_init(&routine_iterated, NULL, BARRIER_HEIGHT);
+	pthread_t thread_id;
+	pthread_create(&thread_id, NULL, allocate_routine, (void *) &iterate_arg_routine);
+	pthread_barrier_wait(&routine_allocated);
+	ret = iterate_wrapper(&iterate_arg_routine);
+	free_allocations(&iterate_arg_routine);
+	pthread_barrier_wait(&routine_iterated);
+	return ret;
+}
+
+int test_iterate_over_abandoned_allocs(void)
+{
+	int ret;
+	iterate_arg_t iterate_arg_routine = {{0}, {0}, {0}, {0}};
+	pthread_t thread_id;
+	pthread_create(&thread_id, NULL, abandoned_allocate_routine, (void *) &iterate_arg_routine);
+	pthread_join(thread_id, NULL);
+	ret = iterate_wrapper(&iterate_arg_routine);
+	free_allocations(&iterate_arg_routine);
+	return ret;
+}
+
+int main()
+{
+	int ret = 0;
+
+	ret = check_and_report("Testing iterate main thread", test_iterate_main_thread);
+
+	ret = -(ret || check_and_report("Testing iterate another thread", test_iterate_another_thread));
+
+	ret = -(ret || check_and_report("Testing iterate over abandoned allocations", test_iterate_over_abandoned_allocs));
+
+	return ret;
+}

libc-test/src/functional/test-mallinfo.c

+/*
+ * Copyright (C) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "test-malloc-stats-common.h"
+
+static int stats_from_mallinfo(malloc_thread_stats_t *stats, long long *total_free_heap_space, int use_mallinfo2)
+{
+	if (use_mallinfo2) {
+		struct mallinfo2 info = mallinfo2();
+		*stats = (malloc_thread_stats_t) {info.hblks, info.hblkhd, info.uordblks};
+		*total_free_heap_space = info.fordblks;
+		return 1;
+	}
+	struct mallinfo info = mallinfo();
+	if (info.hblks < 0 || info.hblkhd < 0 || info.uordblks < 0 || info.fordblks < 0) {
+		t_error("struct mallinfo contains negative numbers\n");
+		return 0;
+	}
+	*stats = (malloc_thread_stats_t) {info.hblks, info.hblkhd, info.uordblks};
+	*total_free_heap_space = info.fordblks;
+	return 1;
+}
+
+static int test_main_thread(int use_mallinfo2)
+{
+	malloc_thread_stats_t total_stats = {0};
+
+	void *ptrs[SIZES_COUNT];
+	for (size_t i = 0; i < SIZES_COUNT; i++) {
+		ptrs[i] = malloc(sizes[i]);
+	}
+	long long free_heap_space_after_allocations = 0;
+	int result = stats_from_mallinfo(&total_stats, &free_heap_space_after_allocations, use_mallinfo2);
+	result &= validate_total_allocated(&total_stats);
+	for (size_t i = 0; i < SIZES_COUNT; i++) {
+		free(ptrs[i]);
+	}
+	long long free_heap_space_after_free = 0;
+	result &= stats_from_mallinfo(&total_stats, &free_heap_space_after_free, use_mallinfo2);
+	result &= validate_all_freed(&total_stats);
+	result &= expect_greater_equal(
+		free_heap_space_after_free,
+		free_heap_space_after_allocations,
+		"free heap space after free",
+		"free heap space after allocations");
+	return result;
+}
+
+static int test_different_threads(int use_mallinfo2)
+{
+	malloc_thread_stats_t total_stats = {0};
+
+	pthread_barrier_t alloc_barrier, free_barrier;
+	if (pthread_barrier_init(&alloc_barrier, NULL, SIZES_COUNT + 1)) {
+		return 0;
+	}
+	if (pthread_barrier_init(&free_barrier, NULL, SIZES_COUNT + 1)) {
+		return 0;
+	}
+
+	thread_data_t thread_data[SIZES_COUNT];
+	for (size_t i = 0; i < SIZES_COUNT; i++) {
+		thread_data[i] = (thread_data_t) {sizes[i], &alloc_barrier, &free_barrier, 0};
+	}
+	pthread_t threads[SIZES_COUNT];
+	for (size_t i = 0; i < SIZES_COUNT; i++) {
+		pthread_create(&threads[i], NULL, allocate_wait_free, &thread_data[i]);
+	}
+	pthread_barrier_wait(&alloc_barrier);
+	long long free_heap_space_after_allocations = 0;
+	int result = stats_from_mallinfo(&total_stats, &free_heap_space_after_allocations, use_mallinfo2);
+	result &= validate_total_allocated(&total_stats);
+
+	pthread_barrier_wait(&free_barrier);
+	for (size_t i = 0; i < SIZES_COUNT; i++) {
+		pthread_join(threads[i], NULL);
+	}
+	long long free_heap_space_after_free = 0;
+	result &= stats_from_mallinfo(&total_stats, &free_heap_space_after_free, use_mallinfo2);
+	result &= validate_all_freed(&total_stats);
+	result &= expect_greater_equal(
+		free_heap_space_after_free,
+		free_heap_space_after_allocations,
+		"free heap space after free",
+		"free heap space after allocations");
+	return result;
+}
+
+static int test_and_report(
+	int (*test_func)(int),
+	int test_func_arg,
+	const char *message)
+{
+	t_printf("%s...", message);
+	if (!test_func(test_func_arg)) {
+		t_error("Failed!\n");
+		return 0;
+	}
+	t_printf("Success\n");
+	return 1;
+}
+
+int main(void)
+{
+	int result = test_and_report(test_main_thread, 0, "Testing mallinfo main thread");
+	result &= test_and_report(test_main_thread, 1, "Testing mallinfo2 main thread");
+	result &= test_and_report(test_different_threads, 0, "Testing mallinfo different threads");
+	result &= test_and_report(test_different_threads, 1, "Testing mallinfo2 different threads");
+	return result == 0;
+}
\ No newline at end of file

libc-test/src/functional/test-malloc-api-common.h

+/*
+ * Copyright (C) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TEST_ITERATE_DISABLE_COMMON_H
+#define TEST_ITERATE_DISABLE_COMMON_H
+
+#include "test.h"
+
+int check_and_report(const char *message, int (*check_func)(void))
+{
+	t_printf("%s...", message);
+	int ret = check_func();
+	if (ret == 0) {
+		t_printf("Success\n");
+	} else {
+		t_error("Failed\n");
+	}
+	return ret;
+}
+
+#endif // TEST_ITERATE_DISABLE_COMMON_H
\ No newline at end of file

libc-test/src/functional/test-malloc-backtrace.c

+/*
+ * Copyright (C) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <malloc.h>
+#include "test-malloc-api-common.h"
+
+static int test_backtrace()
+{
+	return malloc_backtrace(NULL, NULL, 0) != 0;
+}
+
+int main()
+{
+	return check_and_report("Testing malloc_backtrace stub", test_backtrace);
+}
\ No newline at end of file

libc-test/src/functional/test-malloc-disable.c

+/*
+ * Copyright (C) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdio.h>
+#include <malloc.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include <stdint.h>
+#include <memory.h>
+#include <unistd.h>
+
+#include "test-malloc-api-common.h"
+
+#define BARRIER_HEIGHT 2
+
+pthread_barrier_t routine_disabled;
+pthread_barrier_t routine_allocated;
+
+const size_t SLEEP_TIME_SECONDS = 1;
+
+void *disable_routine(void *vargp)
+{
+	malloc_disable();
+	pthread_barrier_wait(&routine_disabled);
+	sleep(SLEEP_TIME_SECONDS);
+	malloc_enable();
+	pthread_barrier_wait(&routine_allocated);
+	return NULL;
+}
+
+int test_malloc_while_disabled(void)
+{
+	int ret = 0;
+	pthread_barrier_init(&routine_disabled, NULL, BARRIER_HEIGHT);
+	pthread_barrier_init(&routine_allocated, NULL, BARRIER_HEIGHT);
+	pthread_t thread_id;
+	pthread_create(&thread_id, NULL, disable_routine, NULL);
+	pthread_barrier_wait(&routine_disabled);
+	time_t start = time(0);
+	int *x = malloc(sizeof(int));
+	pthread_barrier_wait(&routine_allocated);
+	time_t end = time(0);
+	size_t seconds = end - start;
+	if (seconds < SLEEP_TIME_SECONDS) {
+		ret = -1;
+	}
+	free(x);
+	pthread_join(thread_id, NULL);
+
+	return ret;
+}
+
+int main()
+{
+	int ret = 0;
+
+	ret = check_and_report("Testing malloc while disabled", test_malloc_while_disabled);
+
+	return ret;
+}

libc-test/src/functional/test-malloc-info-stats-print.h

+/*
+ * Copyright (C) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TEST_MALLOC_STATS_H
+#define TEST_MALLOC_STATS_H
+
+#define _GNU_SOURCE
+
+#include <pthread.h>
+#include <malloc.h>
+#include <unistd.h>
+#include <sys/syscall.h>
+#include <string.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include "test-malloc-stats-common.h"
+#include "test.h"
+
+#define MAX_TID_LEN 32
+#define STATS_BUFFER_SIZE 4096
+
+typedef struct {
+	char stats_after_allocations[STATS_BUFFER_SIZE];
+	char stats_after_free[STATS_BUFFER_SIZE];
+	char threads[SIZES_COUNT][MAX_TID_LEN + 1];
+} test_results_t;
+
+static void stderr_stats_cb(void);
+
+static int populate_thread_stats(const char *output, const char *thread_id, malloc_thread_stats_t *stats);
+
+static int populate_total_free_heap_space(const char *output, long long *total_free_heap_space);
+
+static int is_thread_in_output(const char *output, const char *thread_id);
+
+static void print_to_file(void *fp, const char *s)
+{
+	fputs(s, fp);
+}
+
+int stats_to_buffer(char *buffer)
+{
+	fflush(stderr);
+	int err_pipe[2];
+	int saved_stderr = dup(STDERR_FILENO);
+	if (pipe(err_pipe) != 0) {
+		perror("Can't create pipe");
+		return 0;
+	}
+	dup2(err_pipe[1], STDERR_FILENO);
+	close(err_pipe[1]);
+	stderr_stats_cb();
+	fflush(stderr);
+	read(err_pipe[0], buffer, STATS_BUFFER_SIZE);
+	dup2(saved_stderr, STDERR_FILENO);
+	return 1;
+}
+
+static test_results_t get_main_thread_test_results(void)
+{
+	test_results_t test_results = {{0},
+	                               {0},
+	                               {{0}}};
+
+	snprintf(test_results.threads[0], MAX_TID_LEN, "%d", (pid_t) syscall(__NR_gettid));
+
+	void *ptrs[SIZES_COUNT] = {0};
+	for (size_t i = 0; i < SIZES_COUNT; i++) {
+		ptrs[i] = malloc(sizes[i]);
+	}
+	stats_to_buffer(test_results.stats_after_allocations);
+	for (size_t i = 0; i < SIZES_COUNT; i++) {
+		free(ptrs[i]);
+	}
+	stats_to_buffer(test_results.stats_after_free);
+	return test_results;
+}
+
+static test_results_t get_different_threads_test_results(void)
+{
+	test_results_t test_results = {{0},
+	                               {0},
+	                               {{0}}};
+	pthread_barrier_t alloc_barrier, free_barrier;
+	if (pthread_barrier_init(&alloc_barrier, NULL, SIZES_COUNT + 1)) {
+		return test_results;
+	}
+	if (pthread_barrier_init(&free_barrier, NULL, SIZES_COUNT + 1)) {
+		return test_results;
+	}
+
+	thread_data_t thread_data[SIZES_COUNT];
+	for (size_t i = 0; i < SIZES_COUNT; i++) {
+		thread_data[i] = (thread_data_t) {sizes[i], &alloc_barrier, &free_barrier, 0};
+	}
+	pthread_t threads[SIZES_COUNT];
+	for (size_t i = 0; i < SIZES_COUNT; i++) {
+		pthread_create(&threads[i], NULL, allocate_wait_free, &thread_data[i]);
+	}
+	pthread_barrier_wait(&alloc_barrier);
+
+	for (size_t i = 0; i < SIZES_COUNT; i++) {
+		snprintf(test_results.threads[i], MAX_TID_LEN, "%d", thread_data[i].self_id);
+	}
+	stats_to_buffer(test_results.stats_after_allocations);
+
+	pthread_barrier_wait(&free_barrier);
+	for (size_t i = 0; i < SIZES_COUNT; i++) {
+		pthread_join(threads[i], NULL);
+	}
+	stats_to_buffer(test_results.stats_after_free);
+	return test_results;
+}
+
+static void *allocate_and_abandon(void *arg)
+{
+	void **allocs = arg;
+	for (size_t i = 0; i < SIZES_COUNT; i++) {
+		allocs[i] = malloc(sizes[i]);
+	}
+	return NULL;
+}
+
+static test_results_t get_abandoned_test_results(void)
+{
+	test_results_t test_results = {{0},
+	                               {0},
+	                               {{0}}};
+	pthread_t t;
+	void *allocs[SIZES_COUNT] = {0};
+	pthread_create(&t, NULL, allocate_and_abandon, &allocs);
+	pthread_join(t, NULL);
+	stats_to_buffer(test_results.stats_after_allocations);
+	for (size_t i = 0; i < SIZES_COUNT; i++) {
+		free(allocs[i]);
+	}
+	stats_to_buffer(test_results.stats_after_free);
+	return test_results;
+}
+
+static int validate_main_thread_test_results(test_results_t *test_results)
+{
+	malloc_thread_stats_t stats_after_allocations;
+	malloc_thread_stats_t stats_after_free;
+	populate_thread_stats(test_results->stats_after_allocations, test_results->threads[0], &stats_after_allocations);
+	populate_thread_stats(test_results->stats_after_free, test_results->threads[0], &stats_after_free);
+	int result = validate_total_allocated(&stats_after_allocations);
+	result &= validate_all_freed(&stats_after_free);
+	return result;
+}
+
+static int validate_allocated_size(size_t size, malloc_thread_stats_t *stats)
+{
+	int result = expect_greater_equal(stats->total_allocated_memory, size, "allocated memory", "size");
+	if (size >= MMAP_THRESHOLD) {
+		result &= expect_greater_equal(stats->total_mmapped_memory, size, "mmapped memory", "size");
+		result &= expect_equal(stats->mmapped_regions, 1, "mmapped regions");
+	}
+	return result;
+}
+
+static int validate_different_threads_test_results(test_results_t *test_results)
+{
+	int result = 1;
+	for (size_t i = 0; i < SIZES_COUNT; i++) {
+		malloc_thread_stats_t thread_stats;
+		result &= populate_thread_stats(test_results->stats_after_allocations, test_results->threads[i], &thread_stats);
+		result &= validate_allocated_size(sizes[i], &thread_stats);
+		if (is_thread_in_output(test_results->stats_after_free, test_results->threads[i])) {
+			t_error("Thread %s did not disappear from output\n", test_results->threads[i]);
+			result = 0;
+		}
+	}
+
+	malloc_thread_stats_t abandoned_stats;
+	result &= populate_thread_stats(test_results->stats_after_free, "abandoned", &abandoned_stats);
+	result &= validate_all_freed(&abandoned_stats);
+
+	long long free_heap_space_after_allocations = 0;
+	long long free_heap_space_after_free = 0;
+	result &= populate_total_free_heap_space(test_results->stats_after_allocations, &free_heap_space_after_allocations);
+	result &= populate_total_free_heap_space(test_results->stats_after_free, &free_heap_space_after_free);
+	result &= expect_greater_equal(
+		free_heap_space_after_free,
+		free_heap_space_after_allocations,
+		"free heap space after free",
+		"free heap space after allocations");
+	return result;
+}
+
+static int validate_abandoned_test_results(test_results_t *test_results)
+{
+	malloc_thread_stats_t stats_after_allocations;
+	malloc_thread_stats_t stats_after_free;
+	populate_thread_stats(test_results->stats_after_allocations, "abandoned", &stats_after_allocations);
+	populate_thread_stats(test_results->stats_after_free, "abandoned", &stats_after_free);
+	int result = validate_total_allocated(&stats_after_allocations);
+	result &= validate_all_freed(&stats_after_free);
+	return result;
+}
+
+static int validate_and_report(
+	test_results_t *test_results,
+	int (*validate_test_results_func)(test_results_t *),
+	const char *message)
+{
+	t_printf("%s...", message);
+	if (!validate_test_results_func(test_results)) {
+		t_error("Failed!\n");
+		return 0;
+	}
+	t_printf("Success\n");
+	return 1;
+}
+
+int main(void)
+{
+	test_results_t main_thread_test_results = get_main_thread_test_results();
+	test_results_t different_threads_test_results = get_different_threads_test_results();
+	test_results_t abandoned_test_results = get_abandoned_test_results();
+	int result = validate_and_report(
+		&main_thread_test_results,
+		validate_main_thread_test_results,
+		"Testing allocations in main thread");
+	result &= validate_and_report(
+		&different_threads_test_results,
+		validate_different_threads_test_results,
+		"Testing allocations in different threads");
+	result &= validate_and_report(
+		&abandoned_test_results,
+		validate_abandoned_test_results,
+		"Testing abandoned allocations");
+	return result == 0;
+}
+
+#endif // TEST_MALLOC_STATS_H

libc-test/src/functional/test-malloc-info.c

+/*
+ * Copyright (C) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdlib.h>
+
+#include "test-malloc-info-stats-print.h"
+#include "libxml/parser.h"
+
+static const xmlChar *get_text_from_children(xmlNodePtr children)
+{
+	for (xmlNodePtr child_node = children; child_node != NULL; child_node = child_node->next) {
+		if (child_node->type == XML_TEXT_NODE) {
+			return child_node->content;
+		}
+	}
+	return NULL;
+}
+
+static const xmlChar *get_attribute(const char *attr_name, xmlNodePtr node)
+{
+	for (xmlAttrPtr curr_attr = node->properties; curr_attr != NULL; curr_attr = curr_attr->next) {
+		if (xmlStrEqual(curr_attr->name, (const xmlChar *) attr_name)) {
+			return get_text_from_children(curr_attr->children);
+		}
+	}
+	return NULL;
+}
+
+static xmlNodePtr find_child_node_with_attr(const char *name, const char *attr_name, const char *attr_value, xmlNodePtr parent)
+{
+	if (parent == NULL) {
+		return NULL;
+	}
+	for (xmlNodePtr curr_node = parent->children; curr_node != NULL; curr_node = curr_node->next) {
+		if (curr_node->type == XML_ELEMENT_NODE && xmlStrEqual(curr_node->name, (xmlChar *) name)) {
+			if (attr_name == NULL) {
+				return curr_node;
+			}
+			if (xmlStrEqual(get_attribute(attr_name, curr_node), (const xmlChar *) attr_value)) {
+				return curr_node;
+			}
+		}
+	}
+	return NULL;
+}
+
+static xmlNodePtr find_child_node(const char *name, xmlNodePtr parent)
+{
+	return find_child_node_with_attr(name, NULL, NULL, parent);
+}
+
+static const char *get_node_text(xmlNodePtr node_ptr)
+{
+	if (node_ptr == NULL) {
+		return NULL;
+	}
+	return (const char *) get_text_from_children(node_ptr->children);
+}
+
+static void stderr_stats_cb(void)
+{
+	malloc_info(0, stderr);
+}
+
+static long long parse_amount(const char *s)
+{
+	if (s == NULL) {
+		return -1;
+	}
+	char *end_ptr;
+	long long result = strtoll(s, &end_ptr, 10);
+	if (end_ptr != s + strlen(s)) {
+		return -1;
+	}
+	if (result < 0) {
+		return -1;
+	}
+	return result;
+}
+
+static xmlNodePtr find_thread_in_document(xmlDocPtr doc_ptr, const char *thread_id)
+{
+	xmlNodePtr root_element = xmlDocGetRootElement(doc_ptr);
+	if (strcmp(thread_id, "abandoned") == 0) {
+		return find_child_node("abandoned", root_element);
+	}
+	return find_child_node_with_attr("thread", "id", thread_id, find_child_node("threads", root_element));
+}
+
+static int populate_thread_stats(const char *output, const char *thread_id, malloc_thread_stats_t *stats)
+{
+	xmlDocPtr doc_ptr = xmlParseDoc((const xmlChar *) output);
+	if (doc_ptr == NULL) {
+		return 0;
+	}
+	xmlNodePtr thread_root = find_thread_in_document(doc_ptr, thread_id);
+	long long total_allocated_memory =
+		parse_amount(get_node_text(find_child_node("total_allocated_memory", thread_root)));
+	long long total_mmapped_memory =
+		parse_amount(get_node_text(find_child_node("total_mmapped_memory", thread_root)));
+	long long mmapped_regions =
+		parse_amount(get_node_text(find_child_node("mmapped_regions", thread_root)));
+	xmlFreeDoc(doc_ptr);
+
+	if (total_allocated_memory == -1 || total_mmapped_memory == -1 || mmapped_regions == -1) {
+		return 0;
+	}
+	stats->total_allocated_memory = total_allocated_memory;
+	stats->total_mmapped_memory = total_mmapped_memory;
+	stats->mmapped_regions = mmapped_regions;
+	return 1;
+}
+
+static int populate_total_free_heap_space(const char *output, long long *total_free_heap_space)
+{
+	xmlDocPtr doc_ptr = xmlParseDoc((const xmlChar *) output);
+	if (doc_ptr == NULL) {
+		return 0;
+	}
+	xmlNodePtr heap_space_root = find_child_node("total_free_heap_space", xmlDocGetRootElement(doc_ptr));
+	long long total_free_heap_space_parsed = parse_amount(get_node_text(heap_space_root));
+	xmlFreeDoc(doc_ptr);
+
+	if (total_free_heap_space_parsed == -1) {
+		return 0;
+	}
+	*total_free_heap_space = total_free_heap_space_parsed;
+	return 1;
+}
+
+static int is_thread_in_output(const char *output, const char *thread_id)
+{
+	xmlDocPtr doc_ptr = xmlParseDoc((const xmlChar *) output);
+	if (doc_ptr == NULL) {
+		return 0;
+	}
+	int result = find_thread_in_document(doc_ptr, thread_id) != NULL;
+	xmlFreeDoc(doc_ptr);
+	return result;
+}

libc-test/src/functional/test-malloc-stats-common.h

+/*
+ * Copyright (C) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef TEST_MALLOC_STATS_COMMON_H
+#define TEST_MALLOC_STATS_COMMON_H
+
+#define _GNU_SOURCE
+
+#include <unistd.h>
+#include <sys/syscall.h>
+#include <stddef.h>
+#include <pthread.h>
+#include <malloc.h>
+#include "test.h"
+
+#define SIZES_COUNT 11
+#define SIZE_ALIGN (8 * sizeof(size_t))
+#define MMAP_THRESHOLD ((0x1c00 * SIZE_ALIGN) - OVERHEAD)
+#define LIST_OVERHEAD (2 * sizeof(void *))
+#define OVERHEAD (2 * sizeof(size_t) + sizeof(void *) + LIST_OVERHEAD)
+
+static size_t sizes[SIZES_COUNT] = {
+	23,
+	32,
+	256,
+	3072,
+	3584,
+	229376,
+	262144,
+	327680,
+	8 * 1024 * 1024,
+	16 * 1024 * 1024,
+	32 * 1024 * 1024
+};
+
+typedef struct {
+	long long mmapped_regions;
+	long long total_mmapped_memory;
+	long long total_allocated_memory;
+} malloc_thread_stats_t;
+
+typedef struct {
+	size_t alloc_size;
+	pthread_barrier_t *alloc_barrier;
+	pthread_barrier_t *free_barrier;
+	pid_t self_id;
+} thread_data_t;
+
+static malloc_thread_stats_t get_total_from_test_sizes()
+{
+	malloc_thread_stats_t total_stats = {0};
+	for (size_t i = 0; i < SIZES_COUNT; i++) {
+		if (sizes[i] > MMAP_THRESHOLD) {
+			total_stats.total_mmapped_memory += sizes[i];
+			total_stats.mmapped_regions++;
+		}
+		total_stats.total_allocated_memory += sizes[i];
+	}
+	return total_stats;
+}
+
+static int expect_greater_equal(long long amt1, long long amt2, const char *amt1_name, const char *amt2_name)
+{
+	if (amt1 >= amt2) {
+		return 1;
+	}
+	t_error("Expected %s(value: %lld) to be >= %s(value: %lld)\n", amt1_name, amt1, amt2_name, amt2);
+	return 0;
+}
+
+static int expect_equal(long long amt, long long value, const char *amt_name)
+{
+	if (amt == value) {
+		return 1;
+	}
+	t_error("Expected %s(value: %lld) to be %lld\n", amt_name, amt, value);
+	return 0;
+}
+
+static int validate_total_allocated(malloc_thread_stats_t *total_stats)
+{
+	malloc_thread_stats_t total_from_test_sizes = get_total_from_test_sizes();
+
+	int result = expect_greater_equal(
+		total_stats->total_allocated_memory,
+		total_from_test_sizes.total_allocated_memory,
+		"allocated memory",
+		"total memory from test sizes");
+	result &= expect_greater_equal(
+		total_stats->total_mmapped_memory,
+		total_from_test_sizes.total_mmapped_memory,
+		"mmapped memory",
+		"total large memory from test sizes");
+	result &= expect_equal(
+		total_stats->mmapped_regions,
+		total_from_test_sizes.mmapped_regions,
+		"mmapped regions");
+	return result;
+}
+
+static int validate_all_freed(malloc_thread_stats_t *total_stats)
+{
+	int result = expect_equal(total_stats->total_allocated_memory, 0, "allocated memory");
+	result &= expect_equal(total_stats->total_mmapped_memory, 0, "mmapped memory");
+	result &= expect_equal(total_stats->mmapped_regions, 0, "mmapped regions");
+	return result;
+}
+
+static void *allocate_wait_free(void *arg)
+{
+	thread_data_t *thread_data = arg;
+	thread_data->self_id = syscall(__NR_gettid);
+	void *alloc = malloc(thread_data->alloc_size);
+	pthread_barrier_wait(thread_data->alloc_barrier);
+	pthread_barrier_wait(thread_data->free_barrier);
+	free(alloc);
+	return NULL;
+}
+
+#endif // TEST_MALLOC_STATS_COMMON_H

libc-test/src/functional/test-malloc-stats-print.c

+/*
+ * Copyright (C) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <regex.h>
+#include "test-malloc-info-stats-print.h"
+
+#define THREAD_DATA_REGEX_LEN (MAX_TID_LEN + 43)
+#define REGEX_NMATCH 1
+
+static void stderr_stats_cb(void)
+{
+	malloc_stats_print(print_to_file, stderr, "");
+}
+
+static int parse_amount(const char **s, long long *destination)
+{
+	char *end_ptr = NULL;
+	long long result = strtoll(*s, &end_ptr, 10);
+	if (end_ptr == *s) {
+		return 0;
+	}
+	*s = end_ptr;
+	if ((!isspace(*end_ptr) && *end_ptr != '\n' && *end_ptr != '\0') || result < 0) {
+		return 0;
+	}
+	*destination = result;
+	return 1;
+}
+
+static const char *find_thread_in_output(const char *output, const char *thread_id)
+{
+	char thread_data_regex_s[THREAD_DATA_REGEX_LEN + 1];
+	snprintf(thread_data_regex_s, THREAD_DATA_REGEX_LEN, "^%s([[:space:]]+[[:digit:]]+){3}[[:space:]]*$", thread_id);
+	regex_t thread_data_regex;
+	if (regcomp(&thread_data_regex, thread_data_regex_s, REG_EXTENDED | REG_NEWLINE) != 0) {
+		t_error("Failed to compile regex %s", thread_data_regex_s);
+		return NULL;
+	}
+
+	regmatch_t pmatch[REGEX_NMATCH];
+	int match_result = regexec(&thread_data_regex, output, REGEX_NMATCH, pmatch, 0);
+	regfree(&thread_data_regex);
+	if (match_result != 0) {
+		return NULL;
+	}
+	return output + pmatch[0].rm_so;
+}
+
+static int populate_thread_stats(const char *output, const char *thread_id, malloc_thread_stats_t *stats)
+{
+	const char *thread_data_start = find_thread_in_output(output, thread_id);
+	if (thread_data_start == NULL) {
+		t_error("Failed to find thread id %s in output", thread_id);
+		return 0;
+	}
+
+	thread_data_start += strlen(thread_id);
+	int result = 1;
+	result &= parse_amount(&thread_data_start, &stats->total_allocated_memory);
+	result &= parse_amount(&thread_data_start, &stats->total_mmapped_memory);
+	result &= parse_amount(&thread_data_start, &stats->mmapped_regions);
+
+	return result;
+}
+
+static int populate_total_free_heap_space(const char *output, long long *total_free_heap_space)
+{
+	const char *free_heap_space_start = strstr(output, "total free heap space:");
+	if (free_heap_space_start == NULL) {
+		return 0;
+	}
+	free_heap_space_start += strlen("total free heap space:");
+	return parse_amount(&free_heap_space_start, total_free_heap_space);
+}
+
+static int is_thread_in_output(const char *output, const char *thread_id)
+{
+	return find_thread_in_output(output, thread_id) != NULL;
+}
\ No newline at end of file

libc-test/src/functional/test-mallopt.c

+/*
+ * Copyright (C) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <malloc.h>
+#include "test-malloc-api-common.h"
+
+static int test_mallopt()
+{
+	return mallopt(0, 0) != 0;
+}
+
+int main()
+{
+	return check_and_report("Testing mallopt stub", test_mallopt);
+}
\ No newline at end of file

libc-test/src/functional/test_src_functional.gni

@@ -79,3 +79,13 @@ functional_list = [
   "wcstol",
   "dlclose_reset",
 ]
+
+malloc_stats_list = [
+  "test-malloc-stats-print",
+  "test-malloc-info",
+  "test-mallinfo",
+  "test-iterate",
+  "test-malloc-disable",
+  "test-malloc-backtrace",
+  "test-mallopt",
+]

libc-test/test_template.gni

@@ -130,6 +130,12 @@ template("test_unittest") {
         ldflags += [ "-Wl,-rpath=./" ]
         libs += [ "//${root_out_dir}/${test_lib_dir}/libtls_init_dso.so" ]
       }
+
+      if (target_name == "test-malloc-info") {
+        include_dirs += [ "//third_party/libxml2/include" ]
+        lib_dirs = [ "//${root_out_dir}/thirdparty/libxml2" ]
+        libs += [ "xml2.z" ]
+      }
     }
 
     if (target_dir == "functionalext/fortify") {

musl_config.gni

@@ -56,6 +56,7 @@ declare_args() {
   if (!is_standard_system) {
     enable_musl_log = false
   }
+  musl_iterate_and_stats_api = true
   musl_secure_level = 1
 }
 

musl_src.gni

@@ -515,7 +515,7 @@ musl_src_file = [
   "src/malloc/malloc.c",
   "src/malloc/malloc_random.c",
   "src/malloc/malloc_usable_size.c",
-  "src/malloc/mallocng/mallinfo.c",
+  "src/malloc/stats.c",
   "src/malloc/memalign.c",
   "src/malloc/posix_memalign.c",
   "src/math/__cos.c",
@@ -2017,6 +2017,7 @@ musl_src_porting_file = [
   "include/info/application_target_sdk_version.h",
   "include/info/device_api_version.h",
   "include/info/fatal_message.h",
+  "include/malloc.h",
   "include/pthread.h",
   "include/fcntl.h",
   "include/poll.h",
@@ -2065,6 +2066,8 @@ musl_src_porting_file = [
   "src/linux/reboot.c",
   "src/linux/tgkill.c",
   "src/malloc/malloc.c",
+  "src/malloc/memalign.c",
+  "src/malloc/stats.c",
   "src/malloc/malloc_random.c",
   "src/multibyte/wcsnrtombs.c",
   "src/network/inet_legacy.c",

musl_template.gni

@@ -312,6 +312,10 @@ template("musl_libs") {
       defines += [ "MALLOC_SECURE_ALL" ]
     }
 
+    if (musl_iterate_and_stats_api) {
+      defines += [ "MUSL_ITERATE_AND_STATS_API" ]
+    }
+
     foreach(s, sources_orig) {
       sources += [ "${target_out_dir}/${musl_ported_dir}/${s}" ]
     }
@@ -486,6 +490,11 @@ template("musl_libs") {
       "src/env/__stack_chk_fail.c",
     ]
 
+    defines = []
+    if (musl_iterate_and_stats_api) {
+      defines += [ "MUSL_ITERATE_AND_STATS_API" ]
+    }
+
     if (musl_arch == "arm") {
       sources_orig += [ "src/thread/${musl_arch}/__set_thread_area.c" ]
     } else if (musl_arch == "aarch64") {

porting/linux/user/include/malloc.h

+#ifndef _MALLOC_H
+#define _MALLOC_H
+
+#include <stdio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define __NEED_size_t
+#define __NEED_ssize_t
+#define __NEED_uintptr_t
+
+#include <bits/alltypes.h>
+
+void *malloc (size_t);
+void *calloc (size_t, size_t);
+void *realloc (void *, size_t);
+void free (void *);
+void *valloc (size_t);
+void *memalign(size_t, size_t);
+
+size_t malloc_usable_size(void *);
+
+struct mallinfo {
+    int arena;
+    int ordblks;
+    int smblks;
+    int hblks;
+    int hblkhd;
+    int usmblks;
+    int fsmblks;
+    int uordblks;
+    int fordblks;
+    int keepcost;
+};
+
+struct mallinfo mallinfo(void);
+
+struct mallinfo2 {
+    size_t arena;
+    size_t ordblks;
+    size_t smblks;
+    size_t hblks;
+    size_t hblkhd;
+    size_t usmblks;
+    size_t fsmblks;
+    size_t uordblks;
+    size_t fordblks;
+    size_t keepcost;
+};
+
+struct mallinfo2 mallinfo2(void);
+
+int malloc_iterate(void* base, size_t size, void (*callback)(void* base, size_t size, void* arg), void* arg);
+void malloc_disable(void);
+void malloc_enable(void);
+
+int malloc_info(int options, FILE* fp);
+void malloc_stats_print(void (*write_cb) (void *, const char *), void *cbopaque, const char *opts);
+
+int mallopt(int param, int value);
+ssize_t malloc_backtrace(void* pointer, uintptr_t* frames, size_t frame_count);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

porting/linux/user/src/hook/musl_malloc.h

 #ifndef _MUSL_MALLOC_H
 #define _MUSL_MALLOC_H
 
+#include "malloc.h"
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -21,6 +23,19 @@ void *__libc_valloc(size_t);
 void *__libc_memalign(size_t, size_t);
 size_t __libc_malloc_usable_size(void *);
 
+struct mallinfo2 __libc_mallinfo2(void);
+
+int __libc_malloc_iterate(void* base, size_t size, void (*callback)(void* base, size_t size, void* arg), void* arg);
+void __libc_malloc_disable(void);
+void __libc_malloc_enable(void);
+
+int __libc_malloc_info(int options, FILE* fp);
+void __libc_malloc_stats_print(void (*write_cb) (void *, const char *), void *cbopaque, const char *opts);
+
+int __libc_mallopt(int param, int value);
+ssize_t __libc_malloc_backtrace(void* pointer, uintptr_t* frames, size_t frame_count);
+
+
 #ifdef __cplusplus
 }
 #endif

porting/linux/user/src/hook/musl_malloc_dispatch.h

@@ -18,6 +18,17 @@ typedef void* (*MallocVallocType)(size_t);
 typedef void (*MallocFreeType)(void*);
 typedef void* (*MallocMemalignType)(size_t, size_t);
 typedef size_t (*MallocMallocUsableSizeType)(void*);
+
+typedef struct mallinfo (*MallinfoType)(void);
+typedef struct mallinfo2 (*Mallinfo2Type)(void);
+typedef int (*MallocIterateType)(void*, size_t, void (*callback)(void*, size_t, void*), void*);
+typedef void (*MallocDisableType)(void);
+typedef void (*MallocEnableType)(void);
+typedef int (*MallocInfoType)(int, FILE*);
+typedef void (*MallocStatsPrintType)(void (*) (void *, const char *), void *, const char *);
+typedef int (*MalloptType)(int, int);
+typedef ssize_t (*MallocBacktraceType)(void*, uintptr_t*, size_t);
+
 typedef bool (*GetHookFlagType)();
 typedef bool (*SetHookFlagType)(bool);
 
@@ -31,6 +42,15 @@ struct MallocDispatchType {
 	MallocFreeType free;
 	MallocMemalignType memalign;
 	MallocMallocUsableSizeType malloc_usable_size;
+	MallinfoType mallinfo;
+	Mallinfo2Type mallinfo2;
+	MallocIterateType malloc_iterate;
+	MallocDisableType malloc_disable;
+	MallocEnableType malloc_enable;
+	MallocInfoType malloc_info;
+	MallocStatsPrintType malloc_stats_print;
+	MalloptType mallopt;
+	MallocBacktraceType malloc_backtrace;
 	GetHookFlagType get_hook_flag;
 	SetHookFlagType set_hook_flag;
 };

porting/linux/user/src/internal/malloc_impl.h

@@ -2,6 +2,7 @@
 #define MALLOC_IMPL_H
 
 #include <sys/mman.h>
+#include "pthread.h"
 #include "malloc_config.h"
 
 hidden void *__expand_heap(size_t *);
@@ -10,11 +11,20 @@ hidden void __malloc_donate(char *, char *);
 
 hidden void *__memalign(size_t, size_t);
 
+typedef struct occupied_bin_s {
+	struct chunk *head, *tail;
+	volatile int lock[2];
+} occupied_bin_t;
+ 
 struct chunk {
 	size_t psize, csize;
 #ifdef MALLOC_RED_ZONE
 	size_t usize;
 	size_t state;
+#endif
+#ifdef MUSL_ITERATE_AND_STATS_API
+	pthread_t thread_id;
+	struct chunk *next_occupied, *prev_occupied;
 #endif
 	struct chunk *next, *prev;
 };
@@ -28,17 +38,42 @@ struct bin {
 #endif
 };
 
+#ifdef MUSL_ITERATE_AND_STATS_API
+typedef void (*malloc_iterate_callback)(void* base, size_t size, void* arg);
+
+hidden occupied_bin_t *__get_occupied_bin_by_idx(size_t bin_index);
+hidden occupied_bin_t *__get_occupied_bin(struct chunk *c);
+hidden occupied_bin_t *__get_current_occupied_bin();
+hidden void __push_chunk(struct chunk *c);
+hidden void __pop_chunk(struct chunk *c);
+hidden pthread_key_t __get_occupied_bin_key(void);
+hidden size_t __get_total_heap_space(void);
+#endif
+
+#define BINS_COUNT 64
+
 #define SIZE_MASK (-SIZE_ALIGN)
-#ifndef MALLOC_RED_ZONE
-#define SIZE_ALIGN (4*sizeof(size_t))
-#define OVERHEAD (2*sizeof(size_t))
+
+#ifdef MUSL_ITERATE_AND_STATS_API
+#define OCCUPIED_BIN_COUNT 64
+#define OCCUPIED_LIST_OVERHEAD (2*sizeof(void*))
+#define ITERATE_AND_STATS_OVERHEAD (sizeof(void*) + OCCUPIED_LIST_OVERHEAD)
 #else
+#define ITERATE_AND_STATS_OVERHEAD (0)
+#endif
+
+#ifndef MALLOC_RED_ZONE
 #define SIZE_ALIGN (8*sizeof(size_t))
-#define OVERHEAD (4*sizeof(size_t))
+#define OVERHEAD (2*sizeof(size_t) + ITERATE_AND_STATS_OVERHEAD)
+#else
+#define SIZE_ALIGN (16*sizeof(size_t))
+#define OVERHEAD (4*sizeof(size_t) + ITERATE_AND_STATS_OVERHEAD)
 #endif
+
+
 #define MMAP_THRESHOLD (0x1c00*SIZE_ALIGN)
 #ifndef MALLOC_RED_ZONE
-#define DONTCARE 16
+#define DONTCARE OVERHEAD
 #else
 #define DONTCARE OVERHEAD
 #define POINTER_USAGE (2*sizeof(void *))

porting/linux/user/src/malloc/malloc.c

 #define _GNU_SOURCE
 #include <stdlib.h>
-#include <string.h>
 #include <limits.h>
 #include <stdint.h>
 #include <errno.h>
 #include <sys/mman.h>
+#include <sys/prctl.h>
 #include "libc.h"
 #include "atomic.h"
 #include "pthread_impl.h"
 #include "malloc_impl.h"
 #include "malloc_random.h"
-#include <sys/prctl.h>
 
 #if defined(__GNUC__) && defined(__PIC__)
 #define inline inline __attribute__((always_inline))
@@ -23,14 +22,17 @@ void __libc_free(void *p);
 
 static struct {
 	volatile uint64_t binmap;
-	struct bin bins[64];
+	struct bin bins[BINS_COUNT];
 	volatile int free_lock[2];
+#ifdef MUSL_ITERATE_AND_STATS_API
+	occupied_bin_t occupied_bins[OCCUPIED_BIN_COUNT];
+#endif
 #ifdef MALLOC_FREELIST_QUARANTINE
 	struct bin quarantine[QUARANTINE_NUM];
 	size_t quarantined_count[QUARANTINE_NUM];
 	size_t quarantined_size[QUARANTINE_NUM];
 #ifdef MALLOC_RED_ZONE
-	char poison[64];
+	char poison[BINS_COUNT];
 	volatile int poison_lock[2];
 	int poison_count_down;
 #endif
@@ -39,6 +41,48 @@ static struct {
 
 int __malloc_replaced;
 
+#ifdef MUSL_ITERATE_AND_STATS_API
+
+occupied_bin_t detached_occupied_bin;
+
+/* Usable memory only, excluding overhead for chunks */
+size_t total_heap_space = 0;
+volatile int total_heap_space_inc_lock[2];
+volatile int pop_merge_lock[2];
+
+
+size_t __get_total_heap_space(void) {
+	return total_heap_space;
+}
+
+static void occupied_bin_destructor(void *occupied_bin)
+{
+	internal_free(occupied_bin);
+}
+
+occupied_bin_t *__get_occupied_bin_by_idx(size_t bin_index)
+{
+	return &mal.occupied_bins[bin_index];
+}
+
+static inline size_t get_occupied_bin_index(pthread_t thread_id)
+{
+	return (size_t) ((size_t)thread_id % OCCUPIED_BIN_COUNT);
+}
+
+occupied_bin_t *__get_occupied_bin(struct chunk *c)
+{
+	size_t bin_index = get_occupied_bin_index(c->thread_id);
+	return &mal.occupied_bins[bin_index];
+}
+
+occupied_bin_t *__get_current_occupied_bin()
+{
+	size_t bin_index = get_occupied_bin_index(__pthread_self());
+	return &mal.occupied_bins[bin_index];
+}
+#endif
+
 /* Synchronization tools */
 
 static inline struct chunk *encode_chunk(struct chunk *ptr, void *key)
@@ -65,6 +109,122 @@ static inline void unlock(volatile int *lk)
 	}
 }
 
+#ifdef MUSL_ITERATE_AND_STATS_API
+void __push_chunk(struct chunk *c)
+{
+	c->prev_occupied = c->next_occupied = NULL;
+	c->thread_id = 0;
+
+	occupied_bin_t *occupied_bin = __get_current_occupied_bin();
+	lock(occupied_bin->lock);
+
+	if (occupied_bin->head != NULL) {
+		occupied_bin->head->prev_occupied = c;
+		c->next_occupied = occupied_bin->head;
+	} else {
+		occupied_bin->tail = c;
+	}
+	occupied_bin->head = c;
+	c->thread_id = __pthread_self();
+
+	unlock(occupied_bin->lock);
+}
+
+void __pop_chunk(struct chunk *c)
+{
+	lock(pop_merge_lock);
+	
+	if (!c->thread_id) {
+		unlock(pop_merge_lock);
+		return;
+	}
+	occupied_bin_t *occupied_bin = __get_occupied_bin(c);
+	lock(occupied_bin->lock);
+
+	if (c == occupied_bin->head) {
+		occupied_bin->head = c->next_occupied;
+	} else {
+		c->prev_occupied->next_occupied = c->next_occupied;
+	}
+	if (c == occupied_bin->tail) {
+		occupied_bin->tail = c->prev_occupied;
+	} else {
+		c->next_occupied->prev_occupied = c->prev_occupied;
+	}
+	unlock(occupied_bin->lock);
+	unlock(pop_merge_lock);
+}
+#endif
+
+void malloc_disable(void)
+{
+#ifdef MUSL_ITERATE_AND_STATS_API
+	lock(mal.free_lock);
+	lock(total_heap_space_inc_lock);
+	for (size_t i = 0; i < BINS_COUNT; ++i) {
+		lock(mal.bins[i].lock);
+	}
+	// FIXME???
+	// __tl_lock();
+	for (size_t i = 0; i < OCCUPIED_BIN_COUNT; ++i) {
+		lock(mal.occupied_bins[i].lock);
+	}
+#endif
+}
+
+void malloc_enable(void)
+{
+#ifdef MUSL_ITERATE_AND_STATS_API
+	// FIXME???
+	// __tl_unlock();
+	for (size_t i = 0; i < OCCUPIED_BIN_COUNT; ++i) {
+		unlock(mal.occupied_bins[i].lock);
+	}
+	unlock(total_heap_space_inc_lock);
+	unlock(mal.free_lock);
+#endif
+}
+
+#ifdef MUSL_ITERATE_AND_STATS_API
+typedef struct iterate_info_s {
+	uintptr_t start_ptr;
+	uintptr_t end_ptr;
+	malloc_iterate_callback callback;
+	void *arg;
+} iterate_info_t;
+
+static void malloc_iterate_visitor(void *block, size_t block_size, void *arg)
+{
+	iterate_info_t *iterate_info = (iterate_info_t *)arg;
+	if ((uintptr_t)block >= iterate_info->start_ptr && (uintptr_t)block < iterate_info->end_ptr) {
+		iterate_info->callback(block, block_size, iterate_info->arg);
+	}
+}
+
+static void malloc_iterate_occupied_bin(occupied_bin_t *occupied_bin, iterate_info_t *iterate_info)
+{
+	for (struct chunk *c = occupied_bin->head; c != NULL; c = c->next_occupied) {
+		malloc_iterate_visitor(CHUNK_TO_MEM(c), CHUNK_SIZE(c) - OVERHEAD, iterate_info);
+	}
+}
+#endif
+
+int malloc_iterate(void* base, size_t size, void (*callback)(void* base, size_t size, void* arg), void* arg)
+{
+#ifdef MUSL_ITERATE_AND_STATS_API
+	uintptr_t ptr = (uintptr_t)base;
+	uintptr_t end_ptr = ptr + size;
+	iterate_info_t iterate_info = {ptr, end_ptr, callback, arg};
+
+	for (size_t i = 0; i < OCCUPIED_BIN_COUNT; ++i) {
+		occupied_bin_t *occupied_bin = &mal.occupied_bins[i];
+		malloc_iterate_occupied_bin(occupied_bin, &iterate_info);
+	}
+
+#endif
+	return 0;
+}
+
 static inline void lock_bin(int i)
 {
 	lock(mal.bins[i].lock);
@@ -228,7 +388,7 @@ void __dump_heap(int x)
 			c, CHUNK_SIZE(c), bin_index(CHUNK_SIZE(c)),
 			c->csize & 15,
 			NEXT_CHUNK(c)->psize & 15);
-	for (i=0; i<64; i++) {
+	for (i=0; i<BINS_COUNT; i++) {
 		if (mal.bins[i].head != BIN_TO_CHUNK(i) && mal.bins[i].head) {
 			fprintf(stderr, "bin %d: %p\n", i, mal.bins[i].head);
 			if (!(mal.binmap & 1ULL<<i))
@@ -253,8 +413,15 @@ static struct chunk *expand_heap(size_t n)
 
 	lock(heap_lock);
 
+#ifdef MUSL_ITERATE_AND_STATS_API
+	lock(total_heap_space_inc_lock);
+#endif
+
 	p = __expand_heap(&n);
 	if (!p) {
+#ifdef MUSL_ITERATE_AND_STATS_API
+		unlock(total_heap_space_inc_lock);
+#endif
 		unlock(heap_lock);
 		return 0;
 	}
@@ -285,6 +452,11 @@ static struct chunk *expand_heap(size_t n)
 	chunk_checksum_set(w);
 #endif
 
+#ifdef MUSL_ITERATE_AND_STATS_API
+	total_heap_space += n - OVERHEAD;
+	unlock(total_heap_space_inc_lock);
+#endif
+
 	unlock(heap_lock);
 
 	return w;
@@ -473,6 +645,7 @@ void *internal_malloc(size_t n)
 		c = (void *)(base + SIZE_ALIGN - OVERHEAD);
 		c->csize = len - (SIZE_ALIGN - OVERHEAD);
 		c->psize = SIZE_ALIGN - OVERHEAD;
+
 #ifdef MALLOC_RED_ZONE
 		c->state = M_STATE_MMAP | M_STATE_USED;
 		c->usize = user_size;
@@ -480,6 +653,9 @@ void *internal_malloc(size_t n)
 			chunk_poison_set(c);
 		}
 		chunk_checksum_set(c);
+#endif
+#ifdef MUSL_ITERATE_AND_STATS_API
+		__push_chunk(c);
 #endif
 		return CHUNK_TO_MEM(c);
 	}
@@ -531,6 +707,9 @@ void *internal_malloc(size_t n)
 		c->state &= ~M_RZ_POISON;
 	}
 	chunk_checksum_set(c);
+#endif
+#ifdef MUSL_ITERATE_AND_STATS_API
+	__push_chunk(c);
 #endif
 	return CHUNK_TO_MEM(c);
 }
@@ -1044,6 +1223,9 @@ void internal_free(void *p)
 	if (!p) return;
 
 	struct chunk *self = MEM_TO_CHUNK(p);
+#ifdef MUSL_ITERATE_AND_STATS_API
+	__pop_chunk(self);
+#endif
 
 #ifdef MALLOC_RED_ZONE
 	/* This is not a valid chunk for freeing */
@@ -1083,6 +1265,23 @@ void __malloc_donate(char *start, char *end)
 	c->usize = POINTER_USAGE;
 	c->state = M_STATE_BRK;
 	chunk_checksum_set(c);
+#endif
+#ifdef MUSL_ITERATE_AND_STATS_API
+	lock(total_heap_space_inc_lock);
+	total_heap_space += CHUNK_SIZE(c) - OVERHEAD;
 #endif
 	__bin_chunk(c);
+#ifdef MUSL_ITERATE_AND_STATS_API
+	unlock(total_heap_space_inc_lock);
+#endif
+}
+
+int mallopt(int param, int value)
+{
+	return 0;
+}
+
+ssize_t malloc_backtrace(void* pointer, uintptr_t* frames, size_t frame_count)
+{
+	return 0;
 }

porting/linux/user/src/malloc/memalign.c

@@ -30,6 +30,11 @@ void *__memalign(size_t align, size_t len)
 	struct chunk *c = MEM_TO_CHUNK(mem);
 	struct chunk *n = MEM_TO_CHUNK(new);
 
+#ifdef MUSL_ITERATE_AND_STATS_API
+	__pop_chunk(c);
+	__push_chunk(n);
+#endif
+
 	if (IS_MMAPPED(c)) {
 		/* Apply difference between aligned and original
 		 * address to the "extra" field of mmapped chunk.

porting/linux/user/src/malloc/stats.c

+/*
+ * Copyright (C) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <stdarg.h>
+#include <malloc.h>
+#include <errno.h>
+#include <string.h>
+#include "pthread_impl.h"
+#include "malloc_impl.h"
+
+#ifdef MUSL_ITERATE_AND_STATS_API
+#define STAT_PRINTF_MAX_LEN 255
+#define ALLOCATOR_VERSION 1
+#define SEPARATOR_REPEATS 7
+
+typedef void (write_cb_fun)(void *, const char *);
+
+typedef enum {
+	TABLE, XML
+} print_mode;
+
+typedef struct {
+	size_t mmapped_regions;
+	size_t total_mmapped_memory;
+	size_t total_allocated_memory;
+	size_t total_allocated_heap_space;
+} malloc_stats_t;
+
+static void stat_printf(write_cb_fun *write_cb, void *write_cb_arg, const char *fmt, ...)
+{
+	va_list args;
+	va_start(args, fmt);
+	char buf[STAT_PRINTF_MAX_LEN + 1];
+	if (vsnprintf(buf, STAT_PRINTF_MAX_LEN, fmt, args)) {
+		write_cb(write_cb_arg, buf);
+	} else {
+		fprintf(stderr, "Error writing to buffer");
+	}
+	va_end(args);
+}
+
+static void print_thread_stats_table(
+	write_cb_fun *write_cb,
+	void *write_cb_arg,
+	int tid,
+	malloc_stats_t *stats
+)
+{
+	stat_printf(
+		write_cb,
+		write_cb_arg,
+		"%-11d %-23zu %-20zu %-20zu\n",
+		tid,
+		stats->total_allocated_memory,
+		stats->total_mmapped_memory,
+		stats->mmapped_regions
+	);
+}
+
+static void print_amount_xml(write_cb_fun *write_cb, void *write_cb_arg, const char *name, size_t value)
+{
+	stat_printf(write_cb, write_cb_arg, "<%s>%zu</%s>\n", name, value, name);
+}
+
+static void print_thread_specific_amounts_xml(write_cb_fun *write_cb, void *write_cb_arg, malloc_stats_t *stats)
+{
+	print_amount_xml(write_cb, write_cb_arg, "total_allocated_memory", stats->total_allocated_memory);
+	print_amount_xml(write_cb, write_cb_arg, "total_mmapped_memory", stats->total_mmapped_memory);
+	print_amount_xml(write_cb, write_cb_arg, "mmapped_regions", stats->mmapped_regions);
+}
+
+static void print_thread_stats_xml(
+	write_cb_fun *write_cb,
+	void *write_cb_arg,
+	int tid,
+	malloc_stats_t *stats
+)
+{
+	stat_printf(write_cb, write_cb_arg, "<thread id=\"%d\">\n", tid);
+	print_thread_specific_amounts_xml(write_cb, write_cb_arg, stats);
+	stat_printf(write_cb, write_cb_arg, "</thread>\n");
+}
+
+static malloc_stats_t add_up_chunks(occupied_bin_t *occupied_bin)
+{
+	malloc_stats_t stats = {0, 0, 0, 0};
+	for (struct chunk *c = occupied_bin->head; c != NULL; c = c->next_occupied) {
+		size_t chunk_memory = CHUNK_SIZE(c) - OVERHEAD;
+		stats.total_allocated_memory += chunk_memory;
+		if (IS_MMAPPED(c)) {
+			stats.mmapped_regions++;
+			stats.total_mmapped_memory += chunk_memory;
+		} else {
+			stats.total_allocated_heap_space += chunk_memory;
+		}
+	}
+	return stats;
+}
+
+static size_t print_threads(write_cb_fun *write_cb, void *write_cb_arg, print_mode mode)
+{
+	size_t total_allocated_heap_space = 0;
+	
+	for (size_t i = 0; i < OCCUPIED_BIN_COUNT; ++i) {
+		occupied_bin_t *occupied_bin = __get_occupied_bin_by_idx(i);
+		malloc_stats_t stats = add_up_chunks(occupied_bin);
+		total_allocated_heap_space += stats.total_allocated_heap_space;
+		//FIXME: Egor, this is incorrect
+		if (mode == TABLE) {
+			print_thread_stats_table(write_cb, write_cb_arg, 0, &stats);
+		} else {
+			print_thread_stats_xml(write_cb, write_cb_arg, 0, &stats);
+		}
+	}
+
+	return total_allocated_heap_space;
+}
+
+static void print_total_free_heap_space(
+	write_cb_fun *write_cb,
+	void *write_cb_arg,
+	size_t total_allocated_heap_space,
+	print_mode mode
+)
+{
+	if (mode == TABLE) {
+		stat_printf(write_cb, write_cb_arg, "\n");
+		for (size_t i = 0; i < SEPARATOR_REPEATS; i++) {
+			stat_printf(
+				write_cb,
+				write_cb_arg,
+				"-----------"
+			);
+		}
+		stat_printf(
+			write_cb,
+			write_cb_arg,
+			"\ntotal free heap space: %zu\n",
+			__get_total_heap_space() - total_allocated_heap_space
+		);
+	} else {
+		print_amount_xml(
+			write_cb,
+			write_cb_arg,
+			"total_free_heap_space",
+			__get_total_heap_space() - total_allocated_heap_space
+		);
+	}
+}
+
+static void print_to_file(void *fp, const char *s)
+{
+	if (fputs(s, fp) == EOF) {
+		fprintf(stderr, "Error writing to file stream: %s", strerror(errno));
+	}
+}
+
+static void add_stats(malloc_stats_t *destination, const malloc_stats_t *source)
+{
+	destination->total_allocated_memory += source->total_allocated_memory;
+	destination->total_mmapped_memory += source->total_mmapped_memory;
+	destination->mmapped_regions += source->mmapped_regions;
+	destination->total_allocated_heap_space += source->total_allocated_heap_space;
+}
+#endif
+
+int malloc_info(int options, FILE* fp)
+{
+#ifdef MUSL_ITERATE_AND_STATS_API
+	if (options != 0) {
+		errno = EINVAL;
+		return -1;
+	}
+	malloc_disable();
+	stat_printf(print_to_file, fp, "<?xml version=\"1.0\"?>\n");
+	stat_printf(print_to_file, fp, "<malloc version=\"%d\">\n", ALLOCATOR_VERSION);
+	stat_printf(print_to_file, fp, "<threads>\n");
+	size_t total_allocated_heap_space = print_threads(print_to_file, fp, XML);
+	stat_printf(print_to_file, fp, "</threads>\n");
+	print_total_free_heap_space(print_to_file, fp, total_allocated_heap_space, XML);
+	stat_printf(print_to_file, fp, "</malloc>\n");
+	malloc_enable();
+#endif
+	return 0;
+}
+
+void malloc_stats_print(void (*write_cb) (void *, const char *), void *cbopaque, const char *opts)
+{
+#ifdef MUSL_ITERATE_AND_STATS_API
+	malloc_disable();
+	stat_printf(
+		write_cb,
+		cbopaque,
+		"%-11s %-23s %-20s %-20s\n",
+		"thread_id",
+		"total_allocated_memory",
+		"total_mmapped_memory",
+		"mmapped_regions"
+	);
+	size_t total_allocated_heap_space = print_threads(write_cb, cbopaque, TABLE);
+	print_total_free_heap_space(write_cb, cbopaque, total_allocated_heap_space, TABLE);
+	malloc_enable();
+#endif
+}
+
+struct mallinfo2 mallinfo2(void)
+{
+#ifdef MUSL_ITERATE_AND_STATS_API
+	malloc_disable();
+	malloc_stats_t shared_stats = {0, 0, 0, 0};
+	struct __pthread *self, *it;
+	self = it = __pthread_self();
+	//FIXME:
+	// do {
+	// 	malloc_stats_t stats = add_up_chunks(__get_occupied_bin(it));
+	// 	add_stats(&shared_stats, &stats);
+	// 	it = it->next;
+	// } while (it != self);
+
+	struct mallinfo2 res = {
+		.hblks = shared_stats.mmapped_regions,
+		.hblkhd = shared_stats.total_mmapped_memory,
+		.uordblks = shared_stats.total_allocated_memory,
+		.fordblks = __get_total_heap_space() - shared_stats.total_allocated_heap_space
+	};
+	malloc_enable();
+	return res;
+#endif
+	return (struct mallinfo2){};
+}
+
+struct mallinfo mallinfo(void)
+{
+	struct mallinfo2 mallinfo2_res = mallinfo2();
+	return (struct mallinfo) {
+		.hblks = (int) mallinfo2_res.hblks,
+		.hblkhd = (int) mallinfo2_res.hblkhd,
+		.uordblks = (int) mallinfo2_res.uordblks,
+		.fordblks = (int) mallinfo2_res.fordblks,
+	};
+}