From: Narcisa Vasile <navas...@microsoft.com>

Add function to translate Windows error codes to
errno-style error codes. The possible return values are chosen
so that we have as much semantical compatibility between platforms as
possible.
---
 lib/eal/include/rte_thread.h |  5 +-
 lib/eal/windows/rte_thread.c | 90 +++++++++++++++++++++++++++---------
 2 files changed, 71 insertions(+), 24 deletions(-)

diff --git a/lib/eal/include/rte_thread.h b/lib/eal/include/rte_thread.h
index eff00023d7..f3eeb28753 100644
--- a/lib/eal/include/rte_thread.h
+++ b/lib/eal/include/rte_thread.h
@@ -236,9 +236,8 @@ int rte_thread_value_set(rte_thread_key key, const void 
*value);
  *
  * @return
  *   On success, value data pointer (can also be NULL).
- *   On failure, NULL and an error number is set in rte_errno.
- *   rte_errno can be: EINVAL  - Invalid parameter passed.
- *                     ENOEXEC - Specific OS error.
+ *   On failure, NULL and a positive error number is set in rte_errno.
+ *
  */
 __rte_experimental
 void *rte_thread_value_get(rte_thread_key key);
diff --git a/lib/eal/windows/rte_thread.c b/lib/eal/windows/rte_thread.c
index cc319d3628..6ea1dc2a05 100644
--- a/lib/eal/windows/rte_thread.c
+++ b/lib/eal/windows/rte_thread.c
@@ -13,6 +13,54 @@ struct eal_tls_key {
        DWORD thread_index;
 };
 
+/* Translates the most common error codes related to threads */
+static int
+thread_translate_win32_error(DWORD error)
+{
+       switch (error) {
+       case ERROR_SUCCESS:
+               return 0;
+
+       case ERROR_INVALID_PARAMETER:
+               return EINVAL;
+
+       case ERROR_INVALID_HANDLE:
+               return EFAULT;
+
+       case ERROR_NOT_ENOUGH_MEMORY:
+       /* FALLTHROUGH */
+       case ERROR_NO_SYSTEM_RESOURCES:
+               return ENOMEM;
+
+       case ERROR_PRIVILEGE_NOT_HELD:
+       /* FALLTHROUGH */
+       case ERROR_ACCESS_DENIED:
+               return EACCES;
+
+       case ERROR_ALREADY_EXISTS:
+               return EEXIST;
+
+       case ERROR_POSSIBLE_DEADLOCK:
+               return EDEADLK;
+
+       case ERROR_INVALID_FUNCTION:
+       /* FALLTHROUGH */
+       case ERROR_CALL_NOT_IMPLEMENTED:
+               return ENOSYS;
+       }
+
+       return EINVAL;
+}
+
+static int
+thread_log_last_error(const char* message)
+{
+       DWORD error = GetLastError();
+       RTE_LOG(DEBUG, EAL, "GetLastError()=%lu: %s\n", error, message);
+
+       return thread_translate_win32_error(error);
+}
+
 rte_thread_t
 rte_thread_self(void)
 {
@@ -85,18 +133,18 @@ int
 rte_thread_key_create(rte_thread_key *key,
                __rte_unused void (*destructor)(void *))
 {
+       int ret;
+
        *key = malloc(sizeof(**key));
        if ((*key) == NULL) {
                RTE_LOG(DEBUG, EAL, "Cannot allocate TLS key.\n");
-               rte_errno = ENOMEM;
-               return -1;
+               return ENOMEM;
        }
        (*key)->thread_index = TlsAlloc();
        if ((*key)->thread_index == TLS_OUT_OF_INDEXES) {
-               RTE_LOG_WIN32_ERR("TlsAlloc()");
+               ret = thread_log_last_error("TlsAlloc()");
                free(*key);
-               rte_errno = ENOEXEC;
-               return -1;
+               return ret;
        }
        return 0;
 }
@@ -104,16 +152,16 @@ rte_thread_key_create(rte_thread_key *key,
 int
 rte_thread_key_delete(rte_thread_key key)
 {
-       if (!key) {
+       int ret;
+
+       if (key == NULL) {
                RTE_LOG(DEBUG, EAL, "Invalid TLS key.\n");
-               rte_errno = EINVAL;
-               return -1;
+               return EINVAL;
        }
        if (!TlsFree(key->thread_index)) {
-               RTE_LOG_WIN32_ERR("TlsFree()");
+               ret = thread_log_last_error("TlsFree()");
                free(key);
-               rte_errno = ENOEXEC;
-               return -1;
+               return ret;
        }
        free(key);
        return 0;
@@ -122,19 +170,17 @@ rte_thread_key_delete(rte_thread_key key)
 int
 rte_thread_value_set(rte_thread_key key, const void *value)
 {
+       int ret;
        char *p;
 
-       if (!key) {
+       if (key == NULL) {
                RTE_LOG(DEBUG, EAL, "Invalid TLS key.\n");
-               rte_errno = EINVAL;
-               return -1;
+               return EINVAL;
        }
        /* discard const qualifier */
        p = (char *) (uintptr_t) value;
        if (!TlsSetValue(key->thread_index, p)) {
-               RTE_LOG_WIN32_ERR("TlsSetValue()");
-               rte_errno = ENOEXEC;
-               return -1;
+               return thread_log_last_error("TlsSetValue()");
        }
        return 0;
 }
@@ -143,16 +189,18 @@ void *
 rte_thread_value_get(rte_thread_key key)
 {
        void *output;
+       DWORD ret = 0;
 
-       if (!key) {
+       if (key == NULL) {
                RTE_LOG(DEBUG, EAL, "Invalid TLS key.\n");
                rte_errno = EINVAL;
                return NULL;
        }
        output = TlsGetValue(key->thread_index);
-       if (GetLastError() != ERROR_SUCCESS) {
-               RTE_LOG_WIN32_ERR("TlsGetValue()");
-               rte_errno = ENOEXEC;
+       ret = GetLastError();
+       if (ret != 0) {
+               RTE_LOG(DEBUG, EAL, "GetLastError()=%lu: TlsGetValue()\n", ret);
+               rte_errno = thread_translate_win32_error(ret);
                return NULL;
        }
        return output;
-- 
2.31.0.vfs.0.1

Reply via email to