[scan-build] Fix deadlock at failures in libears/ear.c

[steakhal]

Summary

We experienced some deadlocks when we used multiple threads for logging
using scan-builds intercept-build tool when we used multiple threads by
e.g. logging make -j16

(gdb) bt
#0  0x00007f2bb3aff110 in __lll_lock_wait () from /lib/x86_64-linux-gnu/libpthread.so.0
#1  0x00007f2bb3af70a3 in pthread_mutex_lock () from /lib/x86_64-linux-gnu/libpthread.so.0
#2  0x00007f2bb3d152e4 in ?? ()
#3  0x00007ffcc5f0cc80 in ?? ()
#4  0x00007f2bb3d2bf5b in ?? () from /lib64/ld-linux-x86-64.so.2
#5  0x00007f2bb3b5da27 in ?? () from /lib/x86_64-linux-gnu/libc.so.6
#6  0x00007f2bb3b5dbe0 in exit () from /lib/x86_64-linux-gnu/libc.so.6
#7  0x00007f2bb3d144ee in ?? ()
#8  0x746e692f706d742f in ?? ()
#9  0x692d747065637265 in ?? ()
#10 0x2f653631326b3034 in ?? ()
#11 0x646d632e35353532 in ?? ()
#12 0x0000000000000000 in ?? ()

I think the gcc's exit call caused the injected libear.so to be unloaded
by the ld, which in turn called the void on_unload() __attribute__((destructor)).
That tried to acquire an already locked mutex which was left locked in the
bear_report_call() call, that probably encountered some error and
returned early when it forgot to unlock the mutex.

All of these are speculation since from the backtrace I could not verify
if frames 2 and 3 are in fact corresponding to the libear.so module.
But I think it's a fairly safe bet.

So, hereby I'm releasing the held mutex on *all paths*, even if some failure
happens.

PS: I would use lock_guards, but it's C.

[steakhal]

It would be quite difficult to write a test for this issue, so I decided not to.

[NoQ]

Fair enough!

[steakhal]

@tstellar, do you think it worth backporting to 13.0.1?

[steakhal]

Submitted for backporting to 13.0.1: https://github.com/llvm/llvm-project/issues/53541

[steakhal]

We missed the release, let's backport it to 14.0.0.

clang/tools/scan-build-py/lib/libear/ear.c

static void bear_report_call(char const *fun, char const *const argv[]) {
 
   if (!initialized)
     return;
 
   pthread_mutex_lock(&mutex);
   const char *cwd = getcwd(NULL, 0);
   if (0 == cwd) {
     perror("bear: getcwd");
+    pthread_mutex_unlock(&mutex);
     exit(EXIT_FAILURE);
   }
   char const *const out_dir = initial_env[0];
   size_t const path_max_length = strlen(out_dir) + 32;
   char filename[path_max_length];
   if (-1 ==
       snprintf(filename, path_max_length, "%s/%d.cmd", out_dir, getpid())) {
     perror("bear: snprintf");
+    pthread_mutex_unlock(&mutex);
     exit(EXIT_FAILURE);
   }
   FILE *fd = fopen(filename, "a+");
   if (0 == fd) {
     perror("bear: fopen");
+    pthread_mutex_unlock(&mutex);
     exit(EXIT_FAILURE);
   }
   fprintf(fd, "%d%c", getpid(), RS);
   fprintf(fd, "%d%c", getppid(), RS);
   fprintf(fd, "%s%c", fun, RS);
   fprintf(fd, "%s%c", cwd, RS);
   size_t const argc = bear_strings_length(argv);
   for (size_t it = 0; it < argc; ++it) {
     fprintf(fd, "%s%c", argv[it], US);
   }
   fprintf(fd, "%c", GS);
   if (fclose(fd)) {
     perror("bear: fclose");
+    pthread_mutex_unlock(&mutex);
     exit(EXIT_FAILURE);
   }
   free((void *)cwd);
   pthread_mutex_unlock(&mutex);
 }
 
 /* update environment assure that chilren processes will copy the desired
  * behaviour */

 }
 
 static void bear_strings_release(char const **in) {
   for (char const *const *it = in; (it) && (*it); ++it) {
     free((void *)*it);
   }
   free((void *)in);
 }
 No newline at end of file