eal/arm64: support ASan

[dpdk.git] / lib / eal / common / malloc_elem.c

diff --git a/lib/eal/common/malloc_elem.c b/lib/eal/common/malloc_elem.c
index c2c9461..bdd20a1 100644 (file)
--- a/lib/eal/common/malloc_elem.c
+++ b/lib/eal/common/malloc_elem.c
@@ -446,6 +446,8 @@ malloc_elem_alloc(struct malloc_elem *elem, size_t size, unsigned align,
                struct malloc_elem *new_free_elem =
                                RTE_PTR_ADD(new_elem, size + MALLOC_ELEM_OVERHEAD);
 
+               asan_clear_split_alloczone(new_free_elem);
+
                split_elem(elem, new_free_elem);
                malloc_elem_free_list_insert(new_free_elem);
 
@@ -458,6 +460,8 @@ malloc_elem_alloc(struct malloc_elem *elem, size_t size, unsigned align,
                elem->state = ELEM_BUSY;
                elem->pad = old_elem_size;
 
+               asan_clear_alloczone(elem);
+
                /* put a dummy header in padding, to point to real element header */
                if (elem->pad > 0) { /* pad will be at least 64-bytes, as everything
                                     * is cache-line aligned */
@@ -470,12 +474,18 @@ malloc_elem_alloc(struct malloc_elem *elem, size_t size, unsigned align,
                return new_elem;
        }
 
+       asan_clear_split_alloczone(new_elem);
+
        /* we are going to split the element in two. The original element
         * remains free, and the new element is the one allocated.
         * Re-insert original element, in case its new size makes it
         * belong on a different list.
         */
+
        split_elem(elem, new_elem);
+
+       asan_clear_alloczone(new_elem);
+
        new_elem->state = ELEM_BUSY;
        malloc_elem_free_list_insert(elem);
 
@@ -601,6 +611,8 @@ malloc_elem_hide_region(struct malloc_elem *elem, void *start, size_t len)
        if (next && next_elem_is_adjacent(elem)) {
                len_after = RTE_PTR_DIFF(next, hide_end);
                if (len_after >= MALLOC_ELEM_OVERHEAD + MIN_DATA_SIZE) {
+                       asan_clear_split_alloczone(hide_end);
+
                        /* split after */
                        split_elem(elem, hide_end);
 
@@ -615,6 +627,8 @@ malloc_elem_hide_region(struct malloc_elem *elem, void *start, size_t len)
        if (prev && prev_elem_is_adjacent(elem)) {
                len_before = RTE_PTR_DIFF(hide_start, elem);
                if (len_before >= MALLOC_ELEM_OVERHEAD + MIN_DATA_SIZE) {
+                       asan_clear_split_alloczone(hide_start);
+
                        /* split before */
                        split_elem(elem, hide_start);
 
@@ -628,6 +642,8 @@ malloc_elem_hide_region(struct malloc_elem *elem, void *start, size_t len)
                }
        }
 
+       asan_clear_alloczone(elem);
+
        remove_elem(elem);
 }
 
@@ -641,8 +657,10 @@ malloc_elem_resize(struct malloc_elem *elem, size_t size)
        const size_t new_size = size + elem->pad + MALLOC_ELEM_OVERHEAD;
 
        /* if we request a smaller size, then always return ok */
-       if (elem->size >= new_size)
+       if (elem->size >= new_size) {
+               asan_clear_alloczone(elem);
                return 0;
+       }
 
        /* check if there is a next element, it's free and adjacent */
        if (!elem->next || elem->next->state != ELEM_FREE ||
@@ -661,9 +679,15 @@ malloc_elem_resize(struct malloc_elem *elem, size_t size)
                /* now we have a big block together. Lets cut it down a bit, by splitting */
                struct malloc_elem *split_pt = RTE_PTR_ADD(elem, new_size);
                split_pt = RTE_PTR_ALIGN_CEIL(split_pt, RTE_CACHE_LINE_SIZE);
+
+               asan_clear_split_alloczone(split_pt);
+
                split_elem(elem, split_pt);
                malloc_elem_free_list_insert(split_pt);
        }
+
+       asan_clear_alloczone(elem);
+
        return 0;
 }