From: Narcisa Vasile <navas...@microsoft.com>
Add functions for mutex init, destroy, lock, unlock.
Add RTE_STATIC_MUTEX macro to replace static initialization
of mutexes.
Windows does not have a static initializer.
Initialization is only done through InitializeCriticalSection().
The RTE_STATIC_MUTEX calls into the rte_thread_mutex_init()
function that performs the actual mutex initialization.
Signed-off-by: Narcisa Vasile <navas...@microsoft.com>
---
lib/eal/common/rte_thread.c | 61 +++++++++++++++++++++++
lib/eal/include/rte_thread.h | 94 ++++++++++++++++++++++++++++++++++++
lib/eal/version.map | 4 ++
lib/eal/windows/rte_thread.c | 53 ++++++++++++++++++++
4 files changed, 212 insertions(+)
diff --git a/lib/eal/common/rte_thread.c b/lib/eal/common/rte_thread.c
index a0a51bc190..ebae4a8af1 100644
--- a/lib/eal/common/rte_thread.c
+++ b/lib/eal/common/rte_thread.c
@@ -251,6 +251,67 @@ rte_thread_detach(rte_thread_t thread_id)
return pthread_detach((pthread_t)thread_id.opaque_id);
}
+int
+rte_thread_mutex_init(rte_thread_mutex *mutex)
+{
+ int ret = 0;
+ pthread_mutex_t *m = NULL;
+
+ RTE_VERIFY(mutex != NULL);
+
+ m = calloc(1, sizeof(*m));
+ if (m == NULL) {
+ RTE_LOG(DEBUG, EAL, "Unable to initialize mutex. Insufficient
memory!\n");
+ ret = ENOMEM;
+ goto cleanup;
+ }
+
+ ret = pthread_mutex_init(m, NULL);
+ if (ret != 0) {
+ RTE_LOG(DEBUG, EAL, "Failed to init mutex. ret = %d\n", ret);
+ goto cleanup;
+ }
+
+ mutex->mutex_id = m;
+ m = NULL;
+
+cleanup:
+ free(m);
+ return ret;
+}
+
+int
+rte_thread_mutex_lock(rte_thread_mutex *mutex)
+{
+ RTE_VERIFY(mutex != NULL);
+
+ return pthread_mutex_lock((pthread_mutex_t *)mutex->mutex_id);
+}
+
+int
+rte_thread_mutex_unlock(rte_thread_mutex *mutex)
+{
+ RTE_VERIFY(mutex != NULL);
+
+ return pthread_mutex_unlock((pthread_mutex_t *)mutex->mutex_id);
+}
+
+int
+rte_thread_mutex_destroy(rte_thread_mutex *mutex)
+{
+ int ret = 0;
+ RTE_VERIFY(mutex != NULL);
+
+ ret = pthread_mutex_destroy((pthread_mutex_t *)mutex->mutex_id);
+ if (ret != 0)
+ RTE_LOG(DEBUG, EAL, "Unable to destroy mutex, ret = %d\n", ret);
+
+ free(mutex->mutex_id);
+ mutex->mutex_id = NULL;
+
+ return ret;
+}
+
int
rte_thread_key_create(rte_thread_key *key, void (*destructor)(void *))
{
diff --git a/lib/eal/include/rte_thread.h b/lib/eal/include/rte_thread.h
index 098c3ba343..7e813b573d 100644
--- a/lib/eal/include/rte_thread.h
+++ b/lib/eal/include/rte_thread.h
@@ -56,6 +56,26 @@ typedef struct {
#endif /* RTE_HAS_CPUSET */
+#define RTE_DECLARE_MUTEX(private_lock) rte_thread_mutex private_lock
+
+#define RTE_DEFINE_MUTEX(private_lock)\
+RTE_INIT(__rte_ ## private_lock ## _init)\
+{\
+ RTE_VERIFY(rte_thread_mutex_init(&private_lock) == 0);\
+}
+
+#define RTE_STATIC_MUTEX(private_lock)\
+static RTE_DECLARE_MUTEX(private_lock);\
+RTE_DEFINE_MUTEX(private_lock)
+
+
+/**
+ * Thread mutex representation.
+ */
+typedef struct rte_thread_mutex_tag {
+ void *mutex_id; /**< mutex identifier */
+} rte_thread_mutex;
+
/**
* TLS key type, an opaque pointer.
*/
@@ -268,6 +288,28 @@ int rte_thread_join(rte_thread_t thread_id, unsigned long
*value_ptr);
__rte_experimental
int rte_thread_detach(rte_thread_t thread_id);
+/**
+ * Set core affinity of the current thread.
+ * Support both EAL and non-EAL thread and update TLS.
+ *
+ * @param cpusetp
+ * Pointer to CPU affinity to set.
+ *
+ * @return
+ * On success, return 0; otherwise return -1;
+ */
+int rte_thread_set_affinity(rte_cpuset_t *cpusetp);
+
+/**
+ * Get core affinity of the current thread.
+ *
+ * @param cpusetp
+ * Pointer to CPU affinity of current thread.
+ * It presumes input is not NULL, otherwise it causes panic.
+ *
+ */
+void rte_thread_get_affinity(rte_cpuset_t *cpusetp);
+
#endif /* RTE_HAS_CPUSET */
/**
@@ -287,6 +329,58 @@ __rte_experimental
int rte_thread_set_priority(rte_thread_t thread_id,
enum rte_thread_priority priority);
+/**
+ * Initializes a mutex.
+ *
+ * @param mutex
+ * The mutex to be initialized.
+ *
+ * @return
+ * On success, return 0.
+ * On failure, return a positive errno-style error number.
+ */
+__rte_experimental
+int rte_thread_mutex_init(rte_thread_mutex *mutex);
+
+/**
+ * Locks a mutex.
+ *
+ * @param mutex
+ * The mutex to be locked.
+ *
+ * @return
+ * On success, return 0.
+ * On failure, return a positive errno-style error number.
+ */
+__rte_experimental
+int rte_thread_mutex_lock(rte_thread_mutex *mutex);
+
+/**
+ * Unlocks a mutex.
+ *
+ * @param mutex
+ * The mutex to be unlocked.
+ *
+ * @return
+ * On success, return 0.
+ * On failure, return a positive errno-style error number.
+ */
+__rte_experimental
+int rte_thread_mutex_unlock(rte_thread_mutex *mutex);
+
+/**
+ * Releases all resources associated with a mutex.
+ *
+ * @param mutex
+ * The mutex to be uninitialized.
+ *
+ * @return
+ * On success, return 0.
+ * On failure, return a positive errno-style error number.
+ */
+__rte_experimental
+int rte_thread_mutex_destroy(rte_thread_mutex *mutex);
+
/**
* Create a TLS data key visible to all threads in the process.
* the created key is later used to get/set a value.
diff --git a/lib/eal/version.map b/lib/eal/version.map
index 02994dd3fb..a1c7a8e87d 100644
--- a/lib/eal/version.map
+++ b/lib/eal/version.map
@@ -439,6 +439,10 @@ EXPERIMENTAL {
rte_thread_create;
rte_thread_join;
rte_thread_detach;
+ rte_thread_mutex_init;
+ rte_thread_mutex_lock;
+ rte_thread_mutex_unlock;
+ rte_thread_mutex_destroy;
};
INTERNAL {
diff --git a/lib/eal/windows/rte_thread.c b/lib/eal/windows/rte_thread.c
index e5e420fadd..23f00cfba2 100644
--- a/lib/eal/windows/rte_thread.c
+++ b/lib/eal/windows/rte_thread.c
@@ -447,6 +447,59 @@ rte_thread_detach(rte_thread_t thread_id)
return 0;
}
+int
+rte_thread_mutex_init(rte_thread_mutex *mutex)
+{
+ int ret = 0;
+ CRITICAL_SECTION *m = NULL;
+
+ RTE_VERIFY(mutex != NULL);
+
+ m = calloc(1, sizeof(*m));
+ if (m == NULL) {
+ RTE_LOG(DEBUG, EAL, "Unable to initialize mutex. Insufficient
memory!\n");
+ ret = ENOMEM;
+ goto cleanup;
+ }
+
+ InitializeCriticalSection(m);
+ mutex->mutex_id = m;
+ m = NULL;
+
+cleanup:
+ return ret;
+}
+
+int
+rte_thread_mutex_lock(rte_thread_mutex *mutex)
+{
+ RTE_VERIFY(mutex != NULL);
+
+ EnterCriticalSection(mutex->mutex_id);
+ return 0;
+}
+
+int
+rte_thread_mutex_unlock(rte_thread_mutex *mutex)
+{
+ RTE_VERIFY(mutex != NULL);
+
+ LeaveCriticalSection(mutex->mutex_id);
+ return 0;
+}
+
+int
+rte_thread_mutex_destroy(rte_thread_mutex *mutex)
+{
+ RTE_VERIFY(mutex != NULL);
+
+ DeleteCriticalSection(mutex->mutex_id);
+ free(mutex->mutex_id);
+ mutex->mutex_id = NULL;
+
+ return 0;
+}
+
int
rte_thread_key_create(rte_thread_key *key,
__rte_unused void (*destructor)(void *))
--
2.31.0.vfs.0.1
