malloc: allow removing memory from named heaps

Add an API to remove memory from specified heaps. This will first
check if all elements within the region are free, and that the
region is the original region that was added to the heap (by
comparing its length to length of memory addressed by the
underlying memseg list).

Signed-off-by: Anatoly Burakov <anatoly.burakov@intel.com>

diff --git a/lib/librte_eal/common/include/rte_malloc.h b/lib/librte_eal/common/include/rte_malloc.h
index fb5b6e2f713d845c03375e1faab8d34f0c67abf8..40bae4478dd29e2f5bbd672d355e7ae25f3378d4 100644 (file)
--- a/lib/librte_eal/common/include/rte_malloc.h
+++ b/lib/librte_eal/common/include/rte_malloc.h
@@ -302,6 +302,33 @@ int __rte_experimental
 rte_malloc_heap_memory_add(const char *heap_name, void *va_addr, size_t len,
                rte_iova_t iova_addrs[], unsigned int n_pages, size_t page_sz);
 
+/**
+ * Remove memory chunk from heap with specified name.
+ *
+ * @note Memory chunk being removed must be the same as one that was added;
+ *   partially removing memory chunks is not supported
+ *
+ * @note Memory area must not contain any allocated elements to allow its
+ *   removal from the heap
+ *
+ * @param heap_name
+ *   Name of the heap to remove memory from
+ * @param va_addr
+ *   Virtual address to remove from the heap
+ * @param len
+ *   Length of virtual area to remove from the heap
+ *
+ * @return
+ *   - 0 on success
+ *   - -1 in case of error, with rte_errno set to one of the following:
+ *     EINVAL - one of the parameters was invalid
+ *     EPERM  - attempted to remove memory from a reserved heap
+ *     ENOENT - heap or memory chunk was not found
+ *     EBUSY  - memory chunk still contains data
+ */
+int __rte_experimental
+rte_malloc_heap_memory_remove(const char *heap_name, void *va_addr, size_t len);
+
 /**
  * Creates a new empty malloc heap with a specified name.
  *

diff --git a/lib/librte_eal/common/malloc_heap.c b/lib/librte_eal/common/malloc_heap.c
index 256c25edf4da87eb8adf0672589dff091b52bbe4..adc1669aa30b48ba00957b4bd62dc3d9b340a54c 100644 (file)
--- a/lib/librte_eal/common/malloc_heap.c
+++ b/lib/librte_eal/common/malloc_heap.c
@@ -1023,6 +1023,32 @@ malloc_heap_dump(struct malloc_heap *heap, FILE *f)
        rte_spinlock_unlock(&heap->lock);
 }
 
+static int
+destroy_seg(struct malloc_elem *elem, size_t len)
+{
+       struct malloc_heap *heap = elem->heap;
+       struct rte_memseg_list *msl;
+
+       msl = elem->msl;
+
+       /* this element can be removed */
+       malloc_elem_free_list_remove(elem);
+       malloc_elem_hide_region(elem, elem, len);
+
+       heap->total_size -= len;
+
+       memset(elem, 0, sizeof(*elem));
+
+       /* destroy the fbarray backing this memory */
+       if (rte_fbarray_destroy(&msl->memseg_arr) < 0)
+               return -1;
+
+       /* reset the memseg list */
+       memset(msl, 0, sizeof(*msl));
+
+       return 0;
+}
+
 int
 malloc_heap_add_external_memory(struct malloc_heap *heap, void *va_addr,
                rte_iova_t iova_addrs[], unsigned int n_pages, size_t page_sz)
@@ -1097,6 +1123,34 @@ malloc_heap_add_external_memory(struct malloc_heap *heap, void *va_addr,
        return 0;
 }
 
+int
+malloc_heap_remove_external_memory(struct malloc_heap *heap, void *va_addr,
+               size_t len)
+{
+       struct malloc_elem *elem = heap->first;
+
+       /* find element with specified va address */
+       while (elem != NULL && elem != va_addr) {
+               elem = elem->next;
+               /* stop if we've blown past our VA */
+               if (elem > (struct malloc_elem *)va_addr) {
+                       rte_errno = ENOENT;
+                       return -1;
+               }
+       }
+       /* check if element was found */
+       if (elem == NULL || elem->msl->len != len) {
+               rte_errno = ENOENT;
+               return -1;
+       }
+       /* if element's size is not equal to segment len, segment is busy */
+       if (elem->state == ELEM_BUSY || elem->size != len) {
+               rte_errno = EBUSY;
+               return -1;
+       }
+       return destroy_seg(elem, len);
+}
+
 int
 malloc_heap_create(struct malloc_heap *heap, const char *heap_name)
 {

diff --git a/lib/librte_eal/common/malloc_heap.h b/lib/librte_eal/common/malloc_heap.h
index 237ce9dc274356ecb6f1e6cb74ca0a48aabfede9..e48996d5272fe61daa40aad083b935f4cacf8b56 100644 (file)
--- a/lib/librte_eal/common/malloc_heap.h
+++ b/lib/librte_eal/common/malloc_heap.h
@@ -43,6 +43,10 @@ int
 malloc_heap_add_external_memory(struct malloc_heap *heap, void *va_addr,
                rte_iova_t iova_addrs[], unsigned int n_pages, size_t page_sz);
 
+int
+malloc_heap_remove_external_memory(struct malloc_heap *heap, void *va_addr,
+               size_t len);
+
 int
 malloc_heap_free(struct malloc_elem *elem);
 

diff --git a/lib/librte_eal/common/rte_malloc.c b/lib/librte_eal/common/rte_malloc.c
index ffa945defcbe8dc776ecba1afd230bea99faf1da..fcd5613befafc239a8f830f028cc1f1525d941ef 100644 (file)
--- a/lib/librte_eal/common/rte_malloc.c
+++ b/lib/librte_eal/common/rte_malloc.c
@@ -378,6 +378,45 @@ unlock:
        return ret;
 }
 
+int
+rte_malloc_heap_memory_remove(const char *heap_name, void *va_addr, size_t len)
+{
+       struct rte_mem_config *mcfg = rte_eal_get_configuration()->mem_config;
+       struct malloc_heap *heap = NULL;
+       int ret;
+
+       if (heap_name == NULL || va_addr == NULL || len == 0 ||
+                       strnlen(heap_name, RTE_HEAP_NAME_MAX_LEN) == 0 ||
+                       strnlen(heap_name, RTE_HEAP_NAME_MAX_LEN) ==
+                               RTE_HEAP_NAME_MAX_LEN) {
+               rte_errno = EINVAL;
+               return -1;
+       }
+       rte_rwlock_write_lock(&mcfg->memory_hotplug_lock);
+       /* find our heap */
+       heap = find_named_heap(heap_name);
+       if (heap == NULL) {
+               rte_errno = ENOENT;
+               ret = -1;
+               goto unlock;
+       }
+       if (heap->socket_id < RTE_MAX_NUMA_NODES) {
+               /* cannot remove memory from internal heaps */
+               rte_errno = EPERM;
+               ret = -1;
+               goto unlock;
+       }
+
+       rte_spinlock_lock(&heap->lock);
+       ret = malloc_heap_remove_external_memory(heap, va_addr, len);
+       rte_spinlock_unlock(&heap->lock);
+
+unlock:
+       rte_rwlock_write_unlock(&mcfg->memory_hotplug_lock);
+
+       return ret;
+}
+
 int
 rte_malloc_heap_create(const char *heap_name)
 {

diff --git a/lib/librte_eal/rte_eal_version.map b/lib/librte_eal/rte_eal_version.map
index 02254042c5c14cedde0f631322d24bb77187843c..8c66d0be982a9c90a382c24f8d1a710d37d64dd9 100644 (file)
--- a/lib/librte_eal/rte_eal_version.map
+++ b/lib/librte_eal/rte_eal_version.map
@@ -322,6 +322,7 @@ EXPERIMENTAL {
        rte_malloc_heap_destroy;
        rte_malloc_heap_get_socket;
        rte_malloc_heap_memory_add;
+       rte_malloc_heap_memory_remove;
        rte_malloc_heap_socket_is_external;
        rte_mem_alloc_validator_register;
        rte_mem_alloc_validator_unregister;