X-Git-Url: http://bilbo.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/5843ccab4e336d47ca34f54e68760ac78d242f36..244ffce80a9e2390e24b9788114de037e4ccc0ae:/src/sthread/sthread_impl.cpp?ds=sidebyside

diff --git a/src/sthread/sthread_impl.cpp b/src/sthread/sthread_impl.cpp
index 08c7da5280..4a92967507 100644
--- a/src/sthread/sthread_impl.cpp
+++ b/src/sthread/sthread_impl.cpp
@@ -49,15 +49,29 @@ int sthread_main(int argc, char** argv, char** envp, int (*raw_main)(int, char**
       return raw_main(argc, argv, envp);
     }
 
-  /* Do not intercept valgrind step 1 */
-  if (not strcmp(argv[0], "/usr/bin/valgrind.bin") || not strcmp(argv[0], "/bin/sh")|| not strcmp(argv[0], "/bin/bash")|| not strcmp(argv[0], "gdb")) {
-    printf("sthread refuses to intercept the execution of %s. Running the application unmodified.\n", argv[0]);
-    fflush(stdout);
-    return raw_main(argc, argv, envp);
+  /* Do not intercept system binaries such as valgrind step 1 */
+  std::vector<std::string> binaries = {"/usr/bin/valgrind.bin", "/bin/sh", "/bin/bash", "gdb", "addr2line"};
+  for (int i = 0; envp[i] != nullptr; i++) {
+    auto view = std::string_view(envp[i]);
+    /* If you want to ignore more than one binary, export STHREAD_IGNORE_BINARY1=toto STHREAD_IGNORE_BINARY2=tutu */
+    /* Note that this cannot be configured with --cfg because we are before the main() */
+    if (view.rfind("STHREAD_IGNORE_BINARY", 0) == 0) {
+      view.remove_prefix(std::min(view.rfind("=") + 1, view.size()));
+      binaries.push_back(std::string(view));
+    }
+  }
+  auto binary_view = std::string_view(argv[0]);
+  for (auto binary : binaries) {
+    if (binary_view.rfind(binary) != std::string_view::npos) {
+      printf("sthread refuses to intercept the execution of %s. Running the application unmodified.\n", argv[0]);
+      fflush(stdout);
+      return raw_main(argc, argv, envp);
+    }
   }
 
   /* If not in SMPI, the old main becomes an actor in a newly created simulation */
-  printf("sthread is intercepting the execution of %s\n", argv[0]);
+  printf("sthread is intercepting the execution of %s. If it's not what you want, export STHREAD_IGNORE_BINARY=%s\n",
+         argv[0], argv[0]);
   fflush(stdout);
 
   sg4::Engine e(&argc, argv);
@@ -245,28 +259,76 @@ int sthread_cond_init(sthread_cond_t* cond, sthread_condattr_t* attr)
   intrusive_ptr_add_ref(cv.get());
 
   cond->cond = cv.get();
+  cond->mutex = nullptr;
   return 0;
 }
 int sthread_cond_signal(sthread_cond_t* cond)
 {
   XBT_DEBUG("%s(%p)", __func__, cond);
+
+  if (cond->mutex == nullptr)
+    XBT_WARN("No mutex was associated so far with condition variable %p. Safety checks skipped.", cond);
+  else {
+    auto* owner = static_cast<sg4::Mutex*>(cond->mutex)->get_owner();
+    if (owner == nullptr)
+      XBT_WARN("The mutex associated to condition %p is not currently owned by anyone when calling "
+               "pthread_cond_signal(). The signal could get lost.",
+               cond);
+    else if (owner != simgrid::s4u::Actor::self())
+      XBT_WARN("The mutex associated to condition %p is currently owned by %s, not by the thread currently calling "
+               "calling pthread_cond_signal(). The signal could get lost.",
+               cond, owner->get_cname());
+  }
+
   static_cast<sg4::ConditionVariable*>(cond->cond)->notify_one();
   return 0;
 }
 int sthread_cond_broadcast(sthread_cond_t* cond)
 {
   XBT_DEBUG("%s(%p)", __func__, cond);
+
+  if (cond->mutex == nullptr)
+    XBT_WARN("No mutex was associated so far with condition variable %p. Safety checks skipped.", cond);
+  else {
+    auto* owner = static_cast<sg4::Mutex*>(cond->mutex)->get_owner();
+    if (owner == nullptr)
+      XBT_WARN("The mutex associated to condition %p is not currently owned by anyone when calling "
+               "pthread_cond_broadcast(). The signal could get lost.",
+               cond);
+    else if (owner != simgrid::s4u::Actor::self())
+      XBT_WARN("The mutex associated to condition %p is currently owned by %s, not by the thread currently calling "
+               "calling pthread_cond_broadcast(). The signal could get lost.",
+               cond, owner->get_cname());
+  }
+
   static_cast<sg4::ConditionVariable*>(cond->cond)->notify_all();
   return 0;
 }
 int sthread_cond_wait(sthread_cond_t* cond, sthread_mutex_t* mutex)
 {
   XBT_DEBUG("%s(%p)", __func__, cond);
+
+  if (cond->mutex == nullptr)
+    cond->mutex = mutex->mutex;
+  else if (cond->mutex != mutex->mutex)
+    XBT_WARN("The condition %p is now waited with mutex %p while it was previoulsy waited with mutex %p. sthread may "
+             "not work with such a dangerous code.",
+             cond, cond->mutex, mutex->mutex);
+
   static_cast<sg4::ConditionVariable*>(cond->cond)->wait(static_cast<sg4::Mutex*>(mutex->mutex));
   return 0;
 }
 int sthread_cond_timedwait(sthread_cond_t* cond, sthread_mutex_t* mutex, const struct timespec* abs_timeout)
 {
+  XBT_DEBUG("%s(%p)", __func__, cond);
+
+  if (cond->mutex == nullptr)
+    cond->mutex = mutex->mutex;
+  else if (cond->mutex != mutex->mutex)
+    XBT_WARN("The condition %p is now waited with mutex %p while it was previoulsy waited with mutex %p. sthread may "
+             "not work with such a dangerous code.",
+             cond, cond->mutex, mutex->mutex);
+
   THROW_UNIMPLEMENTED;
 }
 int sthread_cond_destroy(sthread_cond_t* cond)