tsan: print signal num in errno spoiling reports

[dvyukov]

Summary

For errno spoiling reports we only print the stack
where the signal handler is invoked. And the top
frame is the signal handler function, which is supposed
to give the info for debugging.
But in same cases the top frame can be some common thunk,
which does not give much info. E.g. for Go/cgo it's always
runtime.cgoSigtramp.

Print the signal number.
This is what we can easily gather and it may give at least
some hints regarding the issue.

[dvyukov]

fixed code style

[melver]

compiler-rt/lib/tsan/rtl/tsan_report.cpp

310

Is strsignal() available here?

[dvyukov]

compiler-rt/lib/tsan/rtl/tsan_report.cpp

310

We try to not call libc functions, maybe we could call this one, but it says:
"The string can be used only until the next call to strsignal()"
We can't call this in runtime or we may break the program behavior.

[melver]

compiler-rt/lib/tsan/rtl/tsan_report.cpp

310

Right. One option is to build a lookup-table at startup and copy strsignal() strings into that lookup table.

But it might not be worth it.

[dvyukov]

compiler-rt/lib/tsan/rtl/tsan_report.cpp

310

I've seen this report very few times, I don't even remember if I saw it before the current time. I think the number sufficient to debug (there is man 7 signal).

[melver]

compiler-rt/lib/tsan/rtl/tsan_report.cpp

310

LGTM

compiler-rt/lib/tsan/rtl/tsan_interceptors_posix.cpp

 TSAN_INTERCEPTOR(int, pthread_sigmask, int how, const __sanitizer_sigset_t *set,
     __sanitizer_sigset_t *oldset) {
   SCOPED_TSAN_INTERCEPTOR(pthread_sigmask, how, set, oldset);
   return REAL(pthread_sigmask)(how, set, oldset);
 }
 
 namespace __tsan {
 
-static void ReportErrnoSpoiling(ThreadState *thr, uptr pc) {
+static void ReportErrnoSpoiling(ThreadState *thr, uptr pc, int sig) {
   VarSizeStackTrace stack;
   // StackTrace::GetNestInstructionPc(pc) is used because return address is
   // expected, OutputReport() will undo this.
   ObtainCurrentStack(thr, StackTrace::GetNextInstructionPc(pc), &stack);
   ThreadRegistryLock l(&ctx->thread_registry);
   ScopedReport rep(ReportTypeErrnoInSignal);
+  rep.SetSigNum(sig);
   if (!IsFiredSuppression(ctx, ReportTypeErrnoInSignal, stack)) {
     rep.AddStack(stack, true);
     OutputReport(thr, rep);
   }
 }
 
 static void CallUserSignalHandler(ThreadState *thr, bool sync, bool acquire,
                                   int sig, __sanitizer_siginfo *info,
static void CallUserSignalHandler(ThreadState *thr, bool sync, bool acquire,
   // because some SIGTERM handlers do spoil errno but reraise SIGTERM,
   // tsan reports false positive in such case.
   // It's difficult to properly detect this situation (reraise),
   // because in async signal processing case (when handler is called directly
   // from rtl_generic_sighandler) we have not yet received the reraised
   // signal; and it looks too fragile to intercept all ways to reraise a signal.
   if (ShouldReport(thr, ReportTypeErrnoInSignal) && !sync && sig != SIGTERM &&
       errno != 99)
-    ReportErrnoSpoiling(thr, pc);
+    ReportErrnoSpoiling(thr, pc, sig);
   errno = saved_errno;
 }
 
 void ProcessPendingSignalsImpl(ThreadState *thr) {
   atomic_store(&thr->pending_signals, 0, memory_order_relaxed);
   ThreadSignalContext *sctx = SigCtx(thr);
   if (sctx == 0)
     return;

compiler-rt/lib/tsan/rtl/tsan_report.h

public:
   Vector<ReportStack*> stacks;
   Vector<ReportMop*> mops;
   Vector<ReportLocation*> locs;
   Vector<ReportMutex*> mutexes;
   Vector<ReportThread*> threads;
   Vector<Tid> unique_tids;
   ReportStack *sleep;
   int count;
+  int signum = 0;
 
   ReportDesc();
   ~ReportDesc();
 
  private:
   ReportDesc(const ReportDesc&);
   void operator = (const ReportDesc&);
 };
 
 // Format and output the report to the console/log. No additional logic.
 void PrintReport(const ReportDesc *rep);
 void PrintStack(const ReportStack *stack);
 
 }  // namespace __tsan
 
 #endif  // TSAN_REPORT_H

compiler-rt/lib/tsan/rtl/tsan_report.cpp

void PrintReport(const ReportDesc *rep) {
   Decorator d;
   Printf("==================\n");
   const char *rep_typ_str = ReportTypeString(rep->typ, rep->tag);
   Printf("%s", d.Warning());
   Printf("WARNING: ThreadSanitizer: %s (pid=%d)\n", rep_typ_str,
          (int)internal_getpid());
   Printf("%s", d.Default());
 
+  if (rep->typ == ReportTypeErrnoInSignal)
+    Printf("  Signal %u handler invoked at:\n", rep->signum);
+
   if (rep->typ == ReportTypeDeadlock) {
     char thrbuf[kThreadBufSize];
     Printf("  Cycle in lock order graph: ");
     for (uptr i = 0; i < rep->mutexes.Size(); i++)
       PrintMutexShortWithAddress(rep->mutexes[i], " => ");
     PrintMutexShort(rep->mutexes[0], "\n\n");
     CHECK_GT(rep->mutexes.Size(), 0U);
     CHECK_EQ(rep->mutexes.Size() * (flags()->second_deadlock_stack ? 2 : 1),

compiler-rt/lib/tsan/rtl/tsan_rtl.h

public:
   void AddStack(StackTrace stack, bool suppressable = false);
   void AddThread(const ThreadContext *tctx, bool suppressable = false);
   void AddThread(Tid tid, bool suppressable = false);
   void AddUniqueTid(Tid unique_tid);
   int AddMutex(uptr addr, StackID creation_stack_id);
   void AddLocation(uptr addr, uptr size);
   void AddSleep(StackID stack_id);
   void SetCount(int count);
+  void SetSigNum(int sig);
 
   const ReportDesc *GetReport() const;
 
  protected:
   ScopedReportBase(ReportType typ, uptr tag);
   ~ScopedReportBase();
 
  private:

compiler-rt/lib/tsan/rtl/tsan_rtl_report.cpp

 #if !SANITIZER_GO
 void ScopedReportBase::AddSleep(StackID stack_id) {
   rep_->sleep = SymbolizeStackId(stack_id);
 }
 #endif
 
 void ScopedReportBase::SetCount(int count) { rep_->count = count; }
 
+void ScopedReportBase::SetSigNum(int sig) { rep_->signum = sig; }
+
 const ReportDesc *ScopedReportBase::GetReport() const { return rep_; }
 
 ScopedReport::ScopedReport(ReportType typ, uptr tag)
     : ScopedReportBase(typ, tag) {}
 
 ScopedReport::~ScopedReport() {}
 
 // Replays the trace up to last_pos position in the last part

compiler-rt/test/tsan/signal_errno.cpp

int main() {
   pthread_t th;
   pthread_create(&th, 0, sendsignal, 0);
   loop();
   pthread_join(th, 0);
   return 0;
 }
 
 // CHECK: WARNING: ThreadSanitizer: signal handler spoils errno
+// CHECK:   Signal 27 handler invoked at:
 // CHECK:     #0 MyHandler(int, {{(__)?}}siginfo{{(_t)?}}*, void*) {{.*}}signal_errno.cpp
 // CHECK:     main
 // CHECK: SUMMARY: ThreadSanitizer: signal handler spoils errno{{.*}}MyHandler
-