mem: add validator callback
authorAnatoly Burakov <anatoly.burakov@intel.com>
Wed, 11 Apr 2018 12:30:43 +0000 (13:30 +0100)
committerThomas Monjalon <thomas@monjalon.net>
Wed, 11 Apr 2018 19:45:56 +0000 (21:45 +0200)
This API will enable application to register for notifications
on page allocations that are about to happen, giving the application
a chance to allow or deny the allocation when total memory utilization
as a result would be above specified limit on specified socket.

Signed-off-by: Anatoly Burakov <anatoly.burakov@intel.com>
Tested-by: Santosh Shukla <santosh.shukla@caviumnetworks.com>
Tested-by: Hemant Agrawal <hemant.agrawal@nxp.com>
Tested-by: Gowrishankar Muthukrishnan <gowrishankar.m@linux.vnet.ibm.com>
lib/librte_eal/common/eal_common_memalloc.c
lib/librte_eal/common/eal_common_memory.c
lib/librte_eal/common/eal_memalloc.h
lib/librte_eal/common/include/rte_memory.h
lib/librte_eal/rte_eal_version.map

index 2d2d46f..49fd53c 100644 (file)
@@ -22,14 +22,26 @@ struct mem_event_callback_entry {
        rte_mem_event_callback_t clb;
 };
 
+struct mem_alloc_validator_entry {
+       TAILQ_ENTRY(mem_alloc_validator_entry) next;
+       char name[RTE_MEM_ALLOC_VALIDATOR_NAME_LEN];
+       rte_mem_alloc_validator_t clb;
+       int socket_id;
+       size_t limit;
+};
+
 /** Double linked list of actions. */
 TAILQ_HEAD(mem_event_callback_entry_list, mem_event_callback_entry);
+TAILQ_HEAD(mem_alloc_validator_entry_list, mem_alloc_validator_entry);
 
 static struct mem_event_callback_entry_list mem_event_callback_list =
        TAILQ_HEAD_INITIALIZER(mem_event_callback_list);
-
 static rte_rwlock_t mem_event_rwlock = RTE_RWLOCK_INITIALIZER;
 
+static struct mem_alloc_validator_entry_list mem_alloc_validator_list =
+       TAILQ_HEAD_INITIALIZER(mem_alloc_validator_list);
+static rte_rwlock_t mem_alloc_validator_rwlock = RTE_RWLOCK_INITIALIZER;
+
 static struct mem_event_callback_entry *
 find_mem_event_callback(const char *name)
 {
@@ -42,6 +54,18 @@ find_mem_event_callback(const char *name)
        return r;
 }
 
+static struct mem_alloc_validator_entry *
+find_mem_alloc_validator(const char *name, int socket_id)
+{
+       struct mem_alloc_validator_entry *r;
+
+       TAILQ_FOREACH(r, &mem_alloc_validator_list, next) {
+               if (!strcmp(r->name, name) && r->socket_id == socket_id)
+                       break;
+       }
+       return r;
+}
+
 bool
 eal_memalloc_is_contig(const struct rte_memseg_list *msl, void *start,
                size_t len)
@@ -221,3 +245,115 @@ eal_memalloc_mem_event_notify(enum rte_mem_event event, const void *start,
 
        rte_rwlock_read_unlock(&mem_event_rwlock);
 }
+
+int
+eal_memalloc_mem_alloc_validator_register(const char *name,
+               rte_mem_alloc_validator_t clb, int socket_id, size_t limit)
+{
+       struct mem_alloc_validator_entry *entry;
+       int ret, len;
+       if (name == NULL || clb == NULL || socket_id < 0) {
+               rte_errno = EINVAL;
+               return -1;
+       }
+       len = strnlen(name, RTE_MEM_ALLOC_VALIDATOR_NAME_LEN);
+       if (len == 0) {
+               rte_errno = EINVAL;
+               return -1;
+       } else if (len == RTE_MEM_ALLOC_VALIDATOR_NAME_LEN) {
+               rte_errno = ENAMETOOLONG;
+               return -1;
+       }
+       rte_rwlock_write_lock(&mem_alloc_validator_rwlock);
+
+       entry = find_mem_alloc_validator(name, socket_id);
+       if (entry != NULL) {
+               rte_errno = EEXIST;
+               ret = -1;
+               goto unlock;
+       }
+
+       entry = malloc(sizeof(*entry));
+       if (entry == NULL) {
+               rte_errno = ENOMEM;
+               ret = -1;
+               goto unlock;
+       }
+
+       /* callback successfully created and is valid, add it to the list */
+       entry->clb = clb;
+       entry->socket_id = socket_id;
+       entry->limit = limit;
+       snprintf(entry->name, RTE_MEM_ALLOC_VALIDATOR_NAME_LEN, "%s", name);
+       TAILQ_INSERT_TAIL(&mem_alloc_validator_list, entry, next);
+
+       ret = 0;
+
+       RTE_LOG(DEBUG, EAL, "Mem alloc validator '%s' on socket %i with limit %zu registered\n",
+               name, socket_id, limit);
+
+unlock:
+       rte_rwlock_write_unlock(&mem_alloc_validator_rwlock);
+       return ret;
+}
+
+int
+eal_memalloc_mem_alloc_validator_unregister(const char *name, int socket_id)
+{
+       struct mem_alloc_validator_entry *entry;
+       int ret, len;
+
+       if (name == NULL || socket_id < 0) {
+               rte_errno = EINVAL;
+               return -1;
+       }
+       len = strnlen(name, RTE_MEM_ALLOC_VALIDATOR_NAME_LEN);
+       if (len == 0) {
+               rte_errno = EINVAL;
+               return -1;
+       } else if (len == RTE_MEM_ALLOC_VALIDATOR_NAME_LEN) {
+               rte_errno = ENAMETOOLONG;
+               return -1;
+       }
+       rte_rwlock_write_lock(&mem_alloc_validator_rwlock);
+
+       entry = find_mem_alloc_validator(name, socket_id);
+       if (entry == NULL) {
+               rte_errno = ENOENT;
+               ret = -1;
+               goto unlock;
+       }
+       TAILQ_REMOVE(&mem_alloc_validator_list, entry, next);
+       free(entry);
+
+       ret = 0;
+
+       RTE_LOG(DEBUG, EAL, "Mem alloc validator '%s' on socket %i unregistered\n",
+               name, socket_id);
+
+unlock:
+       rte_rwlock_write_unlock(&mem_alloc_validator_rwlock);
+       return ret;
+}
+
+int
+eal_memalloc_mem_alloc_validate(int socket_id, size_t new_len)
+{
+       struct mem_alloc_validator_entry *entry;
+       int ret = 0;
+
+       rte_rwlock_read_lock(&mem_alloc_validator_rwlock);
+
+       TAILQ_FOREACH(entry, &mem_alloc_validator_list, next) {
+               if (entry->socket_id != socket_id || entry->limit > new_len)
+                       continue;
+               RTE_LOG(DEBUG, EAL, "Calling mem alloc validator '%s' on socket %i\n",
+                       entry->name, entry->socket_id);
+               if (entry->clb(socket_id, entry->limit, new_len) < 0)
+                       ret = -1;
+       }
+
+       rte_rwlock_read_unlock(&mem_alloc_validator_rwlock);
+
+       return ret;
+}
index 1f15ff7..24a9ed5 100644 (file)
@@ -652,6 +652,32 @@ rte_mem_event_callback_unregister(const char *name)
        return eal_memalloc_mem_event_callback_unregister(name);
 }
 
+int __rte_experimental
+rte_mem_alloc_validator_register(const char *name,
+               rte_mem_alloc_validator_t clb, int socket_id, size_t limit)
+{
+       /* FreeBSD boots with legacy mem enabled by default */
+       if (internal_config.legacy_mem) {
+               RTE_LOG(DEBUG, EAL, "Registering mem alloc validators not supported\n");
+               rte_errno = ENOTSUP;
+               return -1;
+       }
+       return eal_memalloc_mem_alloc_validator_register(name, clb, socket_id,
+                       limit);
+}
+
+int __rte_experimental
+rte_mem_alloc_validator_unregister(const char *name, int socket_id)
+{
+       /* FreeBSD boots with legacy mem enabled by default */
+       if (internal_config.legacy_mem) {
+               RTE_LOG(DEBUG, EAL, "Registering mem alloc validators not supported\n");
+               rte_errno = ENOTSUP;
+               return -1;
+       }
+       return eal_memalloc_mem_alloc_validator_unregister(name, socket_id);
+}
+
 /* Dump the physical memory layout on console */
 void
 rte_dump_physmem_layout(FILE *f)
index 98b31da..6736fa3 100644 (file)
@@ -66,4 +66,14 @@ void
 eal_memalloc_mem_event_notify(enum rte_mem_event event, const void *start,
                size_t len);
 
+int
+eal_memalloc_mem_alloc_validator_register(const char *name,
+               rte_mem_alloc_validator_t clb, int socket_id, size_t limit);
+
+int
+eal_memalloc_mem_alloc_validator_unregister(const char *name, int socket_id);
+
+int
+eal_memalloc_mem_alloc_validate(int socket_id, size_t new_len);
+
 #endif /* EAL_MEMALLOC_H */
index 3e4c09f..01e7548 100644 (file)
@@ -364,6 +364,69 @@ rte_mem_event_callback_register(const char *name, rte_mem_event_callback_t clb);
 int __rte_experimental
 rte_mem_event_callback_unregister(const char *name);
 
+
+#define RTE_MEM_ALLOC_VALIDATOR_NAME_LEN 64
+/**< maximum length of alloc validator name */
+/**
+ * Function typedef used to register memory allocation validation callbacks.
+ *
+ * Returning 0 will allow allocation attempt to continue. Returning -1 will
+ * prevent allocation from succeeding.
+ */
+typedef int (*rte_mem_alloc_validator_t)(int socket_id,
+               size_t cur_limit, size_t new_len);
+
+/**
+ * @brief Register validator callback for memory allocations.
+ *
+ * Callbacks registered by this function will be called right before memory
+ * allocator is about to trigger allocation of more pages from the system if
+ * said allocation will bring total memory usage above specified limit on
+ * specified socket. User will be able to cancel pending allocation if callback
+ * returns -1.
+ *
+ * @note callbacks will happen while memory hotplug subsystem is write-locked,
+ *       therefore some functions (e.g. `rte_memseg_walk()`) will cause a
+ *       deadlock when called from within such callbacks.
+ *
+ * @param name
+ *   Name associated with specified callback to be added to the list.
+ *
+ * @param clb
+ *   Callback function pointer.
+ *
+ * @param socket_id
+ *   Socket ID on which to watch for allocations.
+ *
+ * @param limit
+ *   Limit above which to trigger callbacks.
+ *
+ * @return
+ *   0 on successful callback register
+ *   -1 on unsuccessful callback register, with rte_errno value indicating
+ *   reason for failure.
+ */
+int __rte_experimental
+rte_mem_alloc_validator_register(const char *name,
+               rte_mem_alloc_validator_t clb, int socket_id, size_t limit);
+
+/**
+ * @brief Unregister validator callback for memory allocations.
+ *
+ * @param name
+ *   Name associated with specified callback to be removed from the list.
+ *
+ * @param socket_id
+ *   Socket ID on which to watch for allocations.
+ *
+ * @return
+ *   0 on successful callback unregister
+ *   -1 on unsuccessful callback unregister, with rte_errno value indicating
+ *   reason for failure.
+ */
+int __rte_experimental
+rte_mem_alloc_validator_unregister(const char *name, int socket_id);
+
 #ifdef __cplusplus
 }
 #endif
index d1ac9ea..2b5b1dc 100644 (file)
@@ -238,6 +238,8 @@ EXPERIMENTAL {
        rte_fbarray_set_used;
        rte_log_register_type_and_pick_level;
        rte_malloc_dump_heaps;
+       rte_mem_alloc_validator_register;
+       rte_mem_alloc_validator_unregister;
        rte_mem_event_callback_register;
        rte_mem_event_callback_unregister;
        rte_mem_iova2virt;