lib/librte_eal/common/malloc_heap.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2010-2014 Intel Corporation
   3  */
   4 #include <stdint.h>
   5 #include <stddef.h>
   6 #include <stdlib.h>
   7 #include <stdio.h>
   8 #include <stdarg.h>
   9 #include <errno.h>
  10 #include <sys/queue.h>
  11
  12 #include <rte_memory.h>
  13 #include <rte_eal.h>
  14 #include <rte_eal_memconfig.h>
  15 #include <rte_launch.h>
  16 #include <rte_per_lcore.h>
  17 #include <rte_lcore.h>
  18 #include <rte_common.h>
  19 #include <rte_string_fns.h>
  20 #include <rte_spinlock.h>
  21 #include <rte_memcpy.h>
  22 #include <rte_atomic.h>
  23
  24 #include "malloc_elem.h"
  25 #include "malloc_heap.h"
  26
  27 static unsigned
  28 check_hugepage_sz(unsigned flags, uint64_t hugepage_sz)
  29 {
  30         unsigned check_flag = 0;
  31
  32         if (!(flags & ~RTE_MEMZONE_SIZE_HINT_ONLY))
  33                 return 1;
  34
  35         switch (hugepage_sz) {
  36         case RTE_PGSIZE_256K:
  37                 check_flag = RTE_MEMZONE_256KB;
  38                 break;
  39         case RTE_PGSIZE_2M:
  40                 check_flag = RTE_MEMZONE_2MB;
  41                 break;
  42         case RTE_PGSIZE_16M:
  43                 check_flag = RTE_MEMZONE_16MB;
  44                 break;
  45         case RTE_PGSIZE_256M:
  46                 check_flag = RTE_MEMZONE_256MB;
  47                 break;
  48         case RTE_PGSIZE_512M:
  49                 check_flag = RTE_MEMZONE_512MB;
  50                 break;
  51         case RTE_PGSIZE_1G:
  52                 check_flag = RTE_MEMZONE_1GB;
  53                 break;
  54         case RTE_PGSIZE_4G:
  55                 check_flag = RTE_MEMZONE_4GB;
  56                 break;
  57         case RTE_PGSIZE_16G:
  58                 check_flag = RTE_MEMZONE_16GB;
  59         }
  60
  61         return check_flag & flags;
  62 }
  63
  64 /*
  65  * Expand the heap with a memseg.
  66  * This reserves the zone and sets a dummy malloc_elem header at the end
  67  * to prevent overflow. The rest of the zone is added to free list as a single
  68  * large free block
  69  */
  70 static void
  71 malloc_heap_add_memseg(struct malloc_heap *heap, struct rte_memseg *ms)
  72 {
  73         struct malloc_elem *start_elem = (struct malloc_elem *)ms->addr;
  74         const size_t elem_size = ms->len - MALLOC_ELEM_OVERHEAD;
  75
  76         malloc_elem_init(start_elem, heap, ms, elem_size);
  77         malloc_elem_insert(start_elem);
  78         malloc_elem_free_list_insert(start_elem);
  79
  80         heap->total_size += elem_size;
  81 }
  82
  83 /*
  84  * Iterates through the freelist for a heap to find a free element
  85  * which can store data of the required size and with the requested alignment.
  86  * If size is 0, find the biggest available elem.
  87  * Returns null on failure, or pointer to element on success.
  88  */
  89 static struct malloc_elem *
  90 find_suitable_element(struct malloc_heap *heap, size_t size,
  91                 unsigned int flags, size_t align, size_t bound, bool contig)
  92 {
  93         size_t idx;
  94         struct malloc_elem *elem, *alt_elem = NULL;
  95
  96         for (idx = malloc_elem_free_list_index(size);
  97                         idx < RTE_HEAP_NUM_FREELISTS; idx++) {
  98                 for (elem = LIST_FIRST(&heap->free_head[idx]);
  99                                 !!elem; elem = LIST_NEXT(elem, free_list)) {
 100                         if (malloc_elem_can_hold(elem, size, align, bound,
 101                                         contig)) {
 102                                 if (check_hugepage_sz(flags, elem->ms->hugepage_sz))
 103                                         return elem;
 104                                 if (alt_elem == NULL)
 105                                         alt_elem = elem;
 106                         }
 107                 }
 108         }
 109
 110         if ((alt_elem != NULL) && (flags & RTE_MEMZONE_SIZE_HINT_ONLY))
 111                 return alt_elem;
 112
 113         return NULL;
 114 }
 115
 116 /*
 117  * Main function to allocate a block of memory from the heap.
 118  * It locks the free list, scans it, and adds a new memseg if the
 119  * scan fails. Once the new memseg is added, it re-scans and should return
 120  * the new element after releasing the lock.
 121  */
 122 void *
 123 malloc_heap_alloc(struct malloc_heap *heap,
 124                 const char *type __attribute__((unused)), size_t size, unsigned flags,
 125                 size_t align, size_t bound, bool contig)
 126 {
 127         struct malloc_elem *elem;
 128
 129         size = RTE_CACHE_LINE_ROUNDUP(size);
 130         align = RTE_CACHE_LINE_ROUNDUP(align);
 131
 132         rte_spinlock_lock(&heap->lock);
 133
 134         elem = find_suitable_element(heap, size, flags, align, bound, contig);
 135         if (elem != NULL) {
 136                 elem = malloc_elem_alloc(elem, size, align, bound, contig);
 137                 /* increase heap's count of allocated elements */
 138                 heap->alloc_count++;
 139         }
 140         rte_spinlock_unlock(&heap->lock);
 141
 142         return elem == NULL ? NULL : (void *)(&elem[1]);
 143 }
 144
 145 int
 146 malloc_heap_free(struct malloc_elem *elem)
 147 {
 148         struct malloc_heap *heap;
 149         struct malloc_elem *ret;
 150
 151         if (!malloc_elem_cookies_ok(elem) || elem->state != ELEM_BUSY)
 152                 return -1;
 153
 154         /* elem may be merged with previous element, so keep heap address */
 155         heap = elem->heap;
 156
 157         rte_spinlock_lock(&(heap->lock));
 158
 159         ret = malloc_elem_free(elem);
 160
 161         rte_spinlock_unlock(&(heap->lock));
 162
 163         return ret != NULL ? 0 : -1;
 164 }
 165
 166 int
 167 malloc_heap_resize(struct malloc_elem *elem, size_t size)
 168 {
 169         int ret;
 170
 171         if (!malloc_elem_cookies_ok(elem) || elem->state != ELEM_BUSY)
 172                 return -1;
 173
 174         rte_spinlock_lock(&(elem->heap->lock));
 175
 176         ret = malloc_elem_resize(elem, size);
 177
 178         rte_spinlock_unlock(&(elem->heap->lock));
 179
 180         return ret;
 181 }
 182
 183 /*
 184  * Function to retrieve data for heap on given socket
 185  */
 186 int
 187 malloc_heap_get_stats(struct malloc_heap *heap,
 188                 struct rte_malloc_socket_stats *socket_stats)
 189 {
 190         size_t idx;
 191         struct malloc_elem *elem;
 192
 193         rte_spinlock_lock(&heap->lock);
 194
 195         /* Initialise variables for heap */
 196         socket_stats->free_count = 0;
 197         socket_stats->heap_freesz_bytes = 0;
 198         socket_stats->greatest_free_size = 0;
 199
 200         /* Iterate through free list */
 201         for (idx = 0; idx < RTE_HEAP_NUM_FREELISTS; idx++) {
 202                 for (elem = LIST_FIRST(&heap->free_head[idx]);
 203                         !!elem; elem = LIST_NEXT(elem, free_list))
 204                 {
 205                         socket_stats->free_count++;
 206                         socket_stats->heap_freesz_bytes += elem->size;
 207                         if (elem->size > socket_stats->greatest_free_size)
 208                                 socket_stats->greatest_free_size = elem->size;
 209                 }
 210         }
 211         /* Get stats on overall heap and allocated memory on this heap */
 212         socket_stats->heap_totalsz_bytes = heap->total_size;
 213         socket_stats->heap_allocsz_bytes = (socket_stats->heap_totalsz_bytes -
 214                         socket_stats->heap_freesz_bytes);
 215         socket_stats->alloc_count = heap->alloc_count;
 216
 217         rte_spinlock_unlock(&heap->lock);
 218         return 0;
 219 }
 220
 221 /*
 222  * Function to retrieve data for heap on given socket
 223  */
 224 void
 225 malloc_heap_dump(struct malloc_heap *heap, FILE *f)
 226 {
 227         struct malloc_elem *elem;
 228
 229         rte_spinlock_lock(&heap->lock);
 230
 231         fprintf(f, "Heap size: 0x%zx\n", heap->total_size);
 232         fprintf(f, "Heap alloc count: %u\n", heap->alloc_count);
 233
 234         elem = heap->first;
 235         while (elem) {
 236                 malloc_elem_dump(elem, f);
 237                 elem = elem->next;
 238         }
 239
 240         rte_spinlock_unlock(&heap->lock);
 241 }
 242
 243 int
 244 rte_eal_malloc_heap_init(void)
 245 {
 246         struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
 247         unsigned ms_cnt;
 248         struct rte_memseg *ms;
 249
 250         if (mcfg == NULL)
 251                 return -1;
 252
 253         for (ms = &mcfg->memseg[0], ms_cnt = 0;
 254                         (ms_cnt < RTE_MAX_MEMSEG) && (ms->len > 0);
 255                         ms_cnt++, ms++) {
 256                 malloc_heap_add_memseg(&mcfg->malloc_heaps[ms->socket_id], ms);
 257         }
 258
 259         return 0;
 260 }