Add a lock to PlatformPOSIX::DoLoadImage

[friss]

Summary

Multiple threads could be calling into DoLoadImage concurrently,
only one should be allowed to create the UtilityFunction.

[clayborg]

source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

1046–1047

We should put the mutex, or better yet a std::once_flag, in the process as an instance variable. The utility function belongs to each process.

[friss]

source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

1046–1047

I don't disagree, but it seemed a little overkill. Would you just put it as a public member? Or add a GetLoadImageUtilityFunctionOnceFlag() accessor?

[clayborg]

source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

1047

Accessor would be fine. The other reason for putting this in the process is multi-threaded code that attempts to use this after the main thread has exited will crash as the static mutex might destruct itself.

[friss]

I heted the idea of hosting the once_flag in Process but using
it in PlatformPOSIX. I did a bigger refactoring where platforms
pass a factory lambda to the accessor and the thread-safe init
is done in the Process class itself using this lambda.

[jingham]

That looks fine to me.

[clayborg]

Much better.

source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

uint32_t PlatformPOSIX::DoLoadImage(lldb_private::Process *process,
   }
   
   DiagnosticManager diagnostics;
   
   ExecutionContext exe_ctx;
   thread_sp->CalculateExecutionContext(exe_ctx);
 
   Status utility_error;
-  
-  // The UtilityFunction is held in the Process.  Platforms don't track the
-  // lifespan of the Targets that use them, we can't put this in the Platform.
-  UtilityFunction *dlopen_utility_func 
-      = process->GetLoadImageUtilityFunction(this);
+  UtilityFunction *dlopen_utility_func;
   ValueList arguments;
   FunctionCaller *do_dlopen_function = nullptr;
   
+  // Multiple threads could be calling into DoLoadImage concurrently,
+  // only one should be allowed to create the UtilityFunction.
+  {
+    static std::mutex do_dlopen_mutex;
+    std::lock_guard<std::mutex> lock(do_dlopen_mutex);
+
+    // The UtilityFunction is held in the Process.  Platforms don't track the
+    // lifespan of the Targets that use them, we can't put this in the Platform.
+    dlopen_utility_func = process->GetLoadImageUtilityFunction(this);
     if (!dlopen_utility_func) {
       // Make the UtilityFunction:
       dlopen_utility_func = MakeLoadImageUtilityFunction(exe_ctx, error);
     }
+  }
   // If we couldn't make it, the error will be in error, so we can exit here.
   if (!dlopen_utility_func)
     return LLDB_INVALID_IMAGE_TOKEN;
     
   do_dlopen_function = dlopen_utility_func->GetFunctionCaller();
   if (!do_dlopen_function) {
     error.SetErrorString("dlopen error: could not get function caller.");
     return LLDB_INVALID_IMAGE_TOKEN;