Merge pull request #438 from ldorau/Make_os_translate_mem_protection_flags_return_umf_result_t

lplewa · web-flow · commit 5751bf112db7 · 2024-04-15T13:28:28.000+02:00
Make os_translate_mem_protection_flags return umf_result_t
diff --git a/src/provider/provider_os_memory.c b/src/provider/provider_os_memory.c
@@ -108,25 +108,29 @@ static umf_result_t nodemask_to_hwloc_nodeset(const unsigned long *nodemask,
     return UMF_RESULT_SUCCESS;
 }
 
-int os_translate_flags(unsigned in_flags, unsigned max,
-                       int (*translate_flag)(unsigned)) {
-    unsigned out_flags = 0;
+umf_result_t os_translate_flags(unsigned in_flags, unsigned max,
+                                umf_result_t (*translate_flag)(unsigned,
+                                                               unsigned *),
+                                unsigned *out_flags) {
+    unsigned out_f = 0;
     for (unsigned n = 1; n < max; n <<= 1) {
         if (in_flags & n) {
-            int f = translate_flag(n);
-            if (f < 0) {
-                return -1;
+            unsigned flag;
+            umf_result_t result = translate_flag(n, &flag);
+            if (result != UMF_RESULT_SUCCESS) {
+                return result;
             }
-            out_flags |= (unsigned)f;
+            out_f |= flag;
             in_flags &= ~n; // clear this bit
         }
     }
 
     if (in_flags != 0) {
-        return -1;
+        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
     }
 
-    return out_flags;
+    *out_flags = out_f;
+    return UMF_RESULT_SUCCESS;
 }
 
 static hwloc_membind_policy_t translate_numa_mode(umf_numa_mode_t mode,
@@ -174,14 +178,15 @@ static int getHwlocMembindFlags(umf_numa_mode_t mode) {
 
 static umf_result_t translate_params(umf_os_memory_provider_params_t *in_params,
                                      os_memory_provider_t *provider) {
+    umf_result_t result;
     int ret;
 
-    ret = os_translate_mem_protection_flags(in_params->protection);
-    if (ret < 0) {
+    result = os_translate_mem_protection_flags(in_params->protection,
+                                               &provider->protection);
+    if (result != UMF_RESULT_SUCCESS) {
         LOG_ERR("incorrect memory protection flags: %u", in_params->protection);
-        return UMF_RESULT_ERROR_INVALID_ARGUMENT;
+        return result;
     }
-    provider->protection = ret;
 
     // NUMA config
     int emptyNodeset = (!in_params->maxnode || !in_params->nodemask);
diff --git a/src/provider/provider_os_memory_internal.h b/src/provider/provider_os_memory_internal.h
@@ -20,10 +20,13 @@ typedef enum umf_purge_advise_t {
     UMF_PURGE_FORCE,
 } umf_purge_advise_t;
 
-int os_translate_flags(unsigned in_flags, unsigned max,
-                       int (*translate_flag)(unsigned));
+umf_result_t os_translate_flags(unsigned in_flags, unsigned max,
+                                umf_result_t (*translate_flag)(unsigned,
+                                                               unsigned *),
+                                unsigned *out_flags);
 
-int os_translate_mem_protection_flags(unsigned protection);
+umf_result_t os_translate_mem_protection_flags(unsigned in_protection,
+                                               unsigned *out_protection);
 
 void *os_mmap(void *hint_addr, size_t length, int prot);
 
diff --git a/src/provider/provider_os_memory_linux.c b/src/provider/provider_os_memory_linux.c
@@ -13,25 +13,31 @@
 #include "provider_os_memory_internal.h"
 #include <umf/providers/provider_os_memory.h>
 
-static int os_translate_mem_protection_one_flag(unsigned protection) {
-    switch (protection) {
+umf_result_t os_translate_mem_protection_one_flag(unsigned in_protection,
+                                                  unsigned *out_protection) {
+    switch (in_protection) {
     case UMF_PROTECTION_NONE:
-        return PROT_NONE;
+        *out_protection = PROT_NONE;
+        return UMF_RESULT_SUCCESS;
     case UMF_PROTECTION_READ:
-        return PROT_READ;
+        *out_protection = PROT_READ;
+        return UMF_RESULT_SUCCESS;
     case UMF_PROTECTION_WRITE:
-        return PROT_WRITE;
+        *out_protection = PROT_WRITE;
+        return UMF_RESULT_SUCCESS;
     case UMF_PROTECTION_EXEC:
-        return PROT_EXEC;
+        *out_protection = PROT_EXEC;
+        return UMF_RESULT_SUCCESS;
     }
-    assert(0);
-    return -1;
+    return UMF_RESULT_ERROR_INVALID_ARGUMENT;
 }
 
-int os_translate_mem_protection_flags(unsigned protection_flags) {
+umf_result_t os_translate_mem_protection_flags(unsigned in_protection,
+                                               unsigned *out_protection) {
     // translate protection - combination of 'umf_mem_protection_flags_t' flags
-    return os_translate_flags(protection_flags, UMF_PROTECTION_MAX,
-                              os_translate_mem_protection_one_flag);
+    return os_translate_flags(in_protection, UMF_PROTECTION_MAX,
+                              os_translate_mem_protection_one_flag,
+                              out_protection);
 }
 
 static int os_translate_purge_advise(umf_purge_advise_t advise) {
diff --git a/src/provider/provider_os_memory_windows.c b/src/provider/provider_os_memory_windows.c
@@ -20,30 +20,38 @@
 static UTIL_ONCE_FLAG Page_size_is_initialized = UTIL_ONCE_FLAG_INIT;
 static size_t Page_size;
 
-int os_translate_mem_protection_flags(unsigned protection) {
-    switch (protection) {
+umf_result_t os_translate_mem_protection_flags(unsigned in_protection,
+                                               unsigned *out_protection) {
+    switch (in_protection) {
     case UMF_PROTECTION_NONE:
-        return PAGE_NOACCESS;
+        *out_protection = PAGE_NOACCESS;
+        return UMF_RESULT_SUCCESS;
     case UMF_PROTECTION_EXEC:
-        return PAGE_EXECUTE;
+        *out_protection = PAGE_EXECUTE;
+        return UMF_RESULT_SUCCESS;
     case (UMF_PROTECTION_EXEC | UMF_PROTECTION_READ):
-        return PAGE_EXECUTE_READ;
+        *out_protection = PAGE_EXECUTE_READ;
+        return UMF_RESULT_SUCCESS;
     case (UMF_PROTECTION_EXEC | UMF_PROTECTION_READ | UMF_PROTECTION_WRITE):
-        return PAGE_EXECUTE_READWRITE;
+        *out_protection = PAGE_EXECUTE_READWRITE;
+        return UMF_RESULT_SUCCESS;
     case (UMF_PROTECTION_EXEC | UMF_PROTECTION_WRITE):
-        return PAGE_EXECUTE_WRITECOPY;
+        *out_protection = PAGE_EXECUTE_WRITECOPY;
+        return UMF_RESULT_SUCCESS;
     case UMF_PROTECTION_READ:
-        return PAGE_READONLY;
+        *out_protection = PAGE_READONLY;
+        return UMF_RESULT_SUCCESS;
     case (UMF_PROTECTION_READ | UMF_PROTECTION_WRITE):
-        return PAGE_READWRITE;
+        *out_protection = PAGE_READWRITE;
+        return UMF_RESULT_SUCCESS;
     case UMF_PROTECTION_WRITE:
-        return PAGE_WRITECOPY;
+        *out_protection = PAGE_WRITECOPY;
+        return UMF_RESULT_SUCCESS;
     }
     LOG_ERR("os_translate_mem_protection_flags(): unsupported protection flag: "
             "%u",
-            protection);
-    assert(0);
-    return -1;
+            in_protection);
+    return UMF_RESULT_ERROR_INVALID_ARGUMENT;
 }
 
 void *os_mmap(void *hint_addr, size_t length, int prot) {
