Rather than relying implicitly on the socket_id value to identify
external heaps vs internal ones that can be expanded on demand by adding
more hugepages, we add an "is_external" flag to the heap structure. As
we do so, we change the heap initialization to use designated
initializers to guarantee as we add new fields that they are properly
zeroed on init. As it stands, many fields are not explicitly set on
first init of the internal malloc heaps.
Signed-off-by: Bruce Richardson <bruce.richardson@intel.com>
---
lib/eal/common/malloc_heap.c | 22 ++++++++++++----------
lib/eal/common/malloc_heap.h | 1 +
lib/eal/common/malloc_mp.c | 5 ++---
lib/eal/common/rte_malloc.c | 14 ++++++++------
4 files changed, 23 insertions(+), 19 deletions(-)
@@ -668,7 +668,7 @@ malloc_heap_alloc_on_heap_id(const char *type, size_t size,
* we just need to request more memory first.
*/
- socket_id = rte_socket_id_by_idx(heap_id);
+ socket_id = heap->is_external ? -1 : rte_socket_id_by_idx(heap_id);
/*
* if socket ID is negative, we cannot find a socket ID for this heap -
* which means it's an external heap. those can have unexpected page
@@ -1362,19 +1362,17 @@ malloc_heap_create(struct malloc_heap *heap, const char *heap_name)
}
/* initialize empty heap */
- heap->alloc_count = 0;
- heap->first = NULL;
- heap->last = NULL;
+ *heap = (struct malloc_heap) {
+ .is_external = 1,
+ .socket_id = next_socket_id,
+ .lock = RTE_SPINLOCK_INITIALIZER,
+ };
LIST_INIT(heap->free_head);
- rte_spinlock_init(&heap->lock);
- heap->total_size = 0;
- heap->socket_id = next_socket_id;
+ strlcpy(heap->name, heap_name, RTE_HEAP_NAME_MAX_LEN);
/* we hold a global mem hotplug writelock, so it's safe to increment */
mcfg->next_socket_id++;
- /* set up name */
- strlcpy(heap->name, heap_name, RTE_HEAP_NAME_MAX_LEN);
return 0;
}
@@ -1425,8 +1423,12 @@ rte_eal_malloc_heap_init(void)
snprintf(heap_name, sizeof(heap_name),
"socket_%i", socket_id);
+
+ *heap = (struct malloc_heap){
+ .lock = RTE_SPINLOCK_INITIALIZER,
+ .socket_id = socket_id,
+ };
strlcpy(heap->name, heap_name, RTE_HEAP_NAME_MAX_LEN);
- heap->socket_id = socket_id;
}
}
@@ -23,6 +23,7 @@ struct malloc_elem;
*/
struct malloc_heap {
rte_spinlock_t lock;
+ uint32_t is_external:1;
LIST_HEAD(, malloc_elem) free_head[RTE_HEAP_NUM_FREELISTS];
struct malloc_elem *volatile first;
struct malloc_elem *volatile last;
@@ -242,10 +242,9 @@ handle_alloc_request(const struct malloc_mp_req *m,
/*
* for allocations, we must only use internal heaps, but since the
* rte_malloc_heap_socket_is_external() is thread-safe and we're already
- * read-locked, we'll have to take advantage of the fact that internal
- * socket ID's are always lower than RTE_MAX_NUMA_NODES.
+ * read-locked, we'll check directly here.
*/
- if (heap->socket_id >= RTE_MAX_NUMA_NODES) {
+ if (heap->is_external == 1) {
RTE_LOG(ERR, EAL, "Attempting to allocate from external heap\n");
return -1;
}
@@ -314,7 +314,7 @@ rte_malloc_heap_socket_is_external(int socket_id)
if ((int)tmp->socket_id == socket_id) {
/* external memory always has large socket ID's */
- ret = tmp->socket_id >= RTE_MAX_NUMA_NODES;
+ ret = tmp->is_external;
break;
}
}
@@ -421,7 +421,7 @@ rte_malloc_heap_memory_add(const char *heap_name, void *va_addr, size_t len,
ret = -1;
goto unlock;
}
- if (heap->socket_id < RTE_MAX_NUMA_NODES) {
+ if (heap->is_external == 0) {
/* cannot add memory to internal heaps */
rte_errno = EPERM;
ret = -1;
@@ -469,7 +469,7 @@ rte_malloc_heap_memory_remove(const char *heap_name, void *va_addr, size_t len)
ret = -1;
goto unlock;
}
- if (heap->socket_id < RTE_MAX_NUMA_NODES) {
+ if (heap->is_external == 0) {
/* cannot remove memory from internal heaps */
rte_errno = EPERM;
ret = -1;
@@ -520,7 +520,7 @@ sync_memory(const char *heap_name, void *va_addr, size_t len, bool attach)
goto unlock;
}
/* we shouldn't be able to sync to internal heaps */
- if (heap->socket_id < RTE_MAX_NUMA_NODES) {
+ if (heap->is_external == 0) {
rte_errno = EPERM;
ret = -1;
goto unlock;
@@ -648,8 +648,10 @@ rte_malloc_heap_destroy(const char *heap_name)
ret = -1;
goto unlock;
}
- /* we shouldn't be able to destroy internal heaps */
- if (heap->socket_id < RTE_MAX_NUMA_NODES) {
+ /* we shouldn't be able to destroy internal heaps, or external heaps
+ * configured to have an internal numa socket id
+ */
+ if (heap->socket_id < RTE_MAX_NUMA_NODES || heap->is_external == 0) {
rte_errno = EPERM;
ret = -1;
goto unlock;