[OpenMP] Create a temp file in /tmp if /dev/shm is not accessible

[tianshilei1992]

Summary

When libomp is initialized, it creates a temp file in /dev/shm to store
registration flag. Some systems, like Android, don't have /dev/shm, then this
feature is disabled by the macro KMP_USE_SHM, though most Linux distributions
have that. However, some customized distribution, such as the one reported in
https://github.com/llvm/llvm-project/issues/53955, doesn't support it either.
It causes a core dump. In this patch, if it is the case, we will try to create a
temporary file in /tmp, and if it still doesn't make it, then we error out.
Note that we don't consider in this patch if the temporary directory has been
set to TMPDIR in this patch. If /tmp is not accessible, we error out.

Fix #53955.

[tianshilei1992]

ping

openmp/runtime/src/kmp_runtime.cpp

27

Hmm, this should be removed. No idea where it comes from.

[jdoerfert]

LG

openmp/runtime/src/kmp_runtime.cpp

6789–6801

start the comment in this line, not the line above

6918

KMP_DEBUG_ASSERT(temp_reg_status_file_name);

[tianshilei1992]

fix comments

[sthibaul]

openmp/runtime/src/kmp_runtime.cpp

6920

This is very obviously wrong (mixing fopen and O_RDONLY), and doesn't build:

/<<PKGBUILDDIR>>/openmp/runtime/src/kmp_runtime.cpp:6920:16: error: no matching function for call to 'fopen'
    FILE *tf = fopen(temp_reg_status_file_name, O_RDONLY);
               ^~~~~
/usr/include/stdio.h:270:26: note: candidate function not viable: no known conversion from 'int' to 'const char *__restrict' for 2nd argumen
extern FILE *__REDIRECT (fopen, (const char *__restrict __filename,

Actually, why using fopen at all? Rather use

fd1 = open(temp_reg_status_file_name, O_RDONLY);
if (fd1 == -1) {
  // give it up now
  return;
}

?

[tianshilei1992]

openmp/runtime/src/kmp_runtime.cpp

6920

Thanks for pointing that out. I should have caught that. I'll fix it right now.

openmp/runtime/src/kmp_runtime.cpp

 #include "kmp_io.h"
 #include "kmp_itt.h"
 #include "kmp_settings.h"
 #include "kmp_stats.h"
 #include "kmp_str.h"
 #include "kmp_wait_release.h"
 #include "kmp_wrapper_getpid.h"
 #include "kmp_dispatch.h"
+#include <cstdio>
 #if KMP_USE_HIER_SCHED
 #include "kmp_dispatch_hier.h"
 #endif
 
 #if OMPT_SUPPORT
 #include "ompt-specific.h"
 #endif
 #if OMPD_SUPPORT

 #if KMP_OS_UNIX && !KMP_OS_DARWIN && KMP_DYNAMIC_LIB
   return __kmp_str_format("__KMP_REGISTERED_LIB_%d_%d", (int)getpid(),
                           (int)getuid());
 #else
   return __kmp_str_format("__KMP_REGISTERED_LIB_%d", (int)getpid());
 #endif
 } // __kmp_reg_status_get
 
+#if defined(KMP_USE_SHM)
+// If /dev/shm is not accessible, we will create a temporary file under /tmp.
+char *temp_reg_status_file_name = nullptr;
+#endif
+
 void __kmp_register_library_startup(void) {
 
   char *name = __kmp_reg_status_name(); // Name of the environment variable.
   int done = 0;
   union {
     double dtime;
     long ltime;
   } time;
if ((fd1 == -1) && (errno == EEXIST)) {
       if (fd1 == -1) { // file didn't open
         // error out here
         __kmp_fatal(KMP_MSG(FunctionError, "Can't open SHM"), KMP_ERR(0),
                     __kmp_msg_null);
       } else {
         // able to open existing file
         shm_preexist = 1;
       }
-    } else if (fd1 == -1) { // SHM didn't open; it was due to error other than
-      // already exists.
+    } else if (fd1 == -1) {
+      // SHM didn't open; it was due to error other than already exists. Try to
+      // create a temp file under /tmp.
+      // TODO: /tmp might not always be the temporary directory. For now we will
+      // not consider TMPDIR. If /tmp is not accessible, we simply error out.
+      char *temp_file_name = __kmp_str_format("/tmp/%sXXXXXX", name);
+      fd1 = mkstemp(temp_file_name);
+      if (fd1 == -1) {
         // error out here.
-      __kmp_fatal(KMP_MSG(FunctionError, "Can't open SHM2"), KMP_ERR(errno),
+        __kmp_fatal(KMP_MSG(FunctionError, "Can't open TEMP"), KMP_ERR(errno),
                     __kmp_msg_null);
       }
+      temp_reg_status_file_name = temp_file_name;
+    }
     if (shm_preexist == 0) {
       // we created SHM now set size
       if (ftruncate(fd1, SHM_SIZE) == -1) {
         // error occured setting size;
         __kmp_fatal(KMP_MSG(FunctionError, "Can't set size of SHM"),
                     KMP_ERR(errno), __kmp_msg_null);
       }
     }

 } // func __kmp_register_library_startup
 
 void __kmp_unregister_library(void) {
 
   char *name = __kmp_reg_status_name();
   char *value = NULL;
 
 #if defined(KMP_USE_SHM)
+  bool use_shm = true;
   char *shm_name = __kmp_str_format("/%s", name);
   int fd1 = shm_open(shm_name, O_RDONLY, 0666);
   if (fd1 == -1) {
-    // file did not open. return.
+    // File did not open. Try the temporary file.
+    use_shm = false;
+    KMP_DEBUG_ASSERT(temp_reg_status_file_name);
+    FILE *tf = fopen(temp_reg_status_file_name, O_RDONLY);
+    if (!tf) {
+      // give it up now.
       return;
     }
+    fd1 = fileno(tf);
+  }
   char *data1 = (char *)mmap(0, SHM_SIZE, PROT_READ, MAP_SHARED, fd1, 0);
   if (data1 != MAP_FAILED) {
     value = __kmp_str_format("%s", data1); // read value from SHM
     munmap(data1, SHM_SIZE);
   }
   close(fd1);
 #else
   value = __kmp_env_get(name);
 #endif
 
   KMP_DEBUG_ASSERT(__kmp_registration_flag != 0);
   KMP_DEBUG_ASSERT(__kmp_registration_str != NULL);
   if (value != NULL && strcmp(value, __kmp_registration_str) == 0) {
 //  Ok, this is our variable. Delete it.
 #if defined(KMP_USE_SHM)
+    if (use_shm) {
       shm_unlink(shm_name); // this removes file in /dev/shm
+    } else {
+      KMP_DEBUG_ASSERT(temp_reg_status_file_name);
+      unlink(temp_reg_status_file_name); // this removes the temp file
+    }
 #else
     __kmp_env_unset(name);
 #endif
   }
 
 #if defined(KMP_USE_SHM)
   KMP_INTERNAL_FREE(shm_name);
+  if (!use_shm) {
+    KMP_DEBUG_ASSERT(temp_reg_status_file_name);
+    KMP_INTERNAL_FREE(temp_reg_status_file_name);
+  }
 #endif
 
   KMP_INTERNAL_FREE(__kmp_registration_str);
   KMP_INTERNAL_FREE(value);
   KMP_INTERNAL_FREE(name);
 
   __kmp_registration_flag = 0;
   __kmp_registration_str = NULL;