[Tsan] Do not flush all streams on exit

[kutuzov.viktor.84]

Summary

This patch completes the changes in rL200922 and rL200923 so the getline_nohang.cc test does not hang on FreeBSD.

[kutuzov.viktor.84]

Related discussion: https://code.google.com/p/thread-sanitizer/issues/detail?id=47

[glider]

IIUC this test adds more calls to REAL(fflush)() than there were before. How comes it prevents any of the tests from hanging?

[dvyukov]

LGTM

[kutuzov.viktor.84]

Alexander, this patch does fflush() for stderr and stdout whereas fflush(0) tries to flush all streams and thus causes deadlock under some circumstances mentioned in rL200922.

[glider]

Got it. LGTM

Closed by commit rL223121 (authored by vkutuzov).

lib/tsan/rtl/tsan_interceptors.cc

TSAN_INTERCEPTOR(uptr, fwrite, const void *p, uptr size, uptr nmemb, void *f) {
   // libc file streams can call user-supplied functions, see fopencookie.
   {
     SCOPED_TSAN_INTERCEPTOR(fwrite, p, size, nmemb, f);
     MemoryAccessRange(thr, pc, (uptr)p, size * nmemb, false);
   }
   return REAL(fwrite)(p, size, nmemb, f);
 }
 
+static void FlushStreams() {
+  // Flushing all the streams here may freeze the process if a child thread is
+  // performing file stream operations at the same time.
+  REAL(fflush)(stdout);
+  REAL(fflush)(stderr);
+}
+
 TSAN_INTERCEPTOR(void, abort, int fake) {
   SCOPED_TSAN_INTERCEPTOR(abort, fake);
-  REAL(fflush)(0);
+  FlushStreams();
   REAL(abort)(fake);
 }
 
 TSAN_INTERCEPTOR(int, puts, const char *s) {
   SCOPED_TSAN_INTERCEPTOR(puts, s);
   MemoryAccessRange(thr, pc, (uptr)s, internal_strlen(s), false);
   return REAL(puts)(s);
 }
TSAN_INTERCEPTOR(int, vfork, int fake) {
   // to return from the function that calls vfork, and that's exactly what
   // we would do. So this would require some assembly trickery as well.
   // Instead we simply turn vfork into fork.
   return WRAP(fork)(fake);
 }
 
 static int OnExit(ThreadState *thr) {
   int status = Finalize(thr);
-  REAL(fflush)(0);
+  FlushStreams();
   return status;
 }
 
 struct TsanInterceptorContext {
   ThreadState *thr;
   const uptr caller_pc;
   const uptr pc;
 };

 #include "sanitizer_common/sanitizer_common_syscalls.inc"
 
 namespace __tsan {
 
 static void finalize(void *arg) {
   ThreadState *thr = cur_thread();
   int status = Finalize(thr);
   // Make sure the output is not lost.
-  // Flushing all the streams here may freeze the process if a child thread is
-  // performing file stream operations at the same time.
-  REAL(fflush)(stdout);
-  REAL(fflush)(stderr);
+  FlushStreams();
   if (status)
     REAL(_exit)(status);
 }
 
 static void unreachable() {
   Report("FATAL: ThreadSanitizer: unreachable called\n");
   Die();
 }