[tsan] Add support for dispatch event sources

[kubamracek]

Summary

GCD has APIs for event sources, we need some more release-acquire pairs to avoid false positives in TSan.

[dvyukov]

LGTM with a nit

lib/tsan/rtl/tsan_libdispatch_mac.cc

286

In the xpc-change you scoped handler outside of SCOPED_INTERCEPTOR scope as:

{
  SCOPED_INTERCEPTOR_RAW(dispatch_source_set_event_handler_callback);
  Acquire(thr, pc, (uptr)source);
}
handler();

Don't we need to do the same here?
We generally don't run user callbacks inside of interceptor scope.

307

same here

330

same here

lib/tsan/rtl/tsan_libdispatch_mac.cc

TSAN_INTERCEPTOR(void, dispatch_group_notify_f, dispatch_group_t group,
   new_context->object_to_release = group;
   dispatch_retain(group);
 
   Release(thr, pc, (uptr)group);
   REAL(dispatch_group_notify_f)(group, q, new_context,
                                 dispatch_callback_wrap_acquire);
 }
 
+TSAN_INTERCEPTOR(void, dispatch_source_set_event_handler,
+                 dispatch_source_t source, dispatch_block_t handler) {
+  SCOPED_TSAN_INTERCEPTOR(dispatch_source_set_event_handler, source, handler);
+  dispatch_block_t new_handler = ^(void) {
+    SCOPED_INTERCEPTOR_RAW(dispatch_source_set_event_handler_callback);
+    Acquire(thr, pc, (uptr)source);
+    handler();
+  };
+  Release(thr, pc, (uptr)source);
+  REAL(dispatch_source_set_event_handler)(source, new_handler);
+}
+
+TSAN_INTERCEPTOR(void, dispatch_source_set_event_handler_f,
+                 dispatch_source_t source, dispatch_function_t handler) {
+  SCOPED_TSAN_INTERCEPTOR(dispatch_source_set_event_handler_f, source, handler);
+  dispatch_block_t block = ^(void) {
+    handler(dispatch_get_context(source));
+  };
+  WRAP(dispatch_source_set_event_handler)(source, block);
+}
+
+TSAN_INTERCEPTOR(void, dispatch_source_set_cancel_handler,
+                 dispatch_source_t source, dispatch_block_t handler) {
+  SCOPED_TSAN_INTERCEPTOR(dispatch_source_set_cancel_handler, source, handler);
+  dispatch_block_t new_handler = ^(void) {
+    SCOPED_INTERCEPTOR_RAW(dispatch_source_set_cancel_handler_callback);
+    Acquire(thr, pc, (uptr)source);
+    handler();
+  };
+  Release(thr, pc, (uptr)source);
+  REAL(dispatch_source_set_cancel_handler)(source, new_handler);
+}
+
+TSAN_INTERCEPTOR(void, dispatch_source_set_cancel_handler_f,
+                 dispatch_source_t source, dispatch_function_t handler) {
+  SCOPED_TSAN_INTERCEPTOR(dispatch_source_set_cancel_handler_f, source,
+                          handler);
+  dispatch_block_t block = ^(void) {
+    handler(dispatch_get_context(source));
+  };
+  WRAP(dispatch_source_set_cancel_handler)(source, block);
+}
+
+TSAN_INTERCEPTOR(void, dispatch_source_set_registration_handler,
+                 dispatch_source_t source, dispatch_block_t handler) {
+  SCOPED_TSAN_INTERCEPTOR(dispatch_source_set_registration_handler, source,
+                          handler);
+  dispatch_block_t new_handler = ^(void) {
+    SCOPED_INTERCEPTOR_RAW(dispatch_source_set_registration_handler_callback);
+    Acquire(thr, pc, (uptr)source);
+    handler();
+  };
+  Release(thr, pc, (uptr)source);
+  REAL(dispatch_source_set_registration_handler)(source, new_handler);
+}
+
+TSAN_INTERCEPTOR(void, dispatch_source_set_registration_handler_f,
+                 dispatch_source_t source, dispatch_function_t handler) {
+  SCOPED_TSAN_INTERCEPTOR(dispatch_source_set_registration_handler_f, source,
+                          handler);
+  dispatch_block_t block = ^(void) {
+    handler(dispatch_get_context(source));
+  };
+  WRAP(dispatch_source_set_registration_handler)(source, block);
+}
+
 }  // namespace __tsan
 
 #endif  // SANITIZER_MAC

test/tsan/Darwin/gcd-source-cancel.mm

+// RUN: %clang_tsan %s -o %t -framework Foundation
+// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+
+#import <Foundation/Foundation.h>
+
+long global;
+
+int main(int argc, const char *argv[]) {
+  dispatch_queue_t queue =
+      dispatch_queue_create("my.queue", DISPATCH_QUEUE_CONCURRENT);
+
+  dispatch_source_t source =
+      dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
+
+  dispatch_source_set_timer(source, dispatch_walltime(NULL, 0), 1e9, 5);
+
+  global = 42;
+
+  dispatch_source_set_cancel_handler(source, ^{
+    fprintf(stderr, "global = %ld\n", global);
+
+    dispatch_sync(dispatch_get_main_queue(), ^{
+      CFRunLoopStop(CFRunLoopGetCurrent());
+    });
+  });
+
+  dispatch_resume(source);
+  dispatch_cancel(source);
+
+  CFRunLoopRun();
+
+  return 0;
+}
+
+// CHECK: global = 42
+// CHECK-NOT: WARNING: ThreadSanitizer

test/tsan/Darwin/gcd-source-cancel2.mm

+// RUN: %clang_tsan %s -o %t -framework Foundation
+// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+
+#import <Foundation/Foundation.h>
+
+long global;
+
+void handler(void *arg) {
+  fprintf(stderr, "global = %ld\n", global);
+
+  dispatch_sync(dispatch_get_main_queue(), ^{
+    CFRunLoopStop(CFRunLoopGetCurrent());
+  });
+}
+
+int main(int argc, const char *argv[]) {
+  dispatch_queue_t queue =
+      dispatch_queue_create("my.queue", DISPATCH_QUEUE_CONCURRENT);
+
+  dispatch_source_t source =
+      dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
+
+  dispatch_source_set_timer(source, dispatch_walltime(NULL, 0), 1e9, 5);
+
+  global = 42;
+
+  dispatch_source_set_cancel_handler_f(source, &handler);
+
+  dispatch_resume(source);
+  dispatch_cancel(source);
+
+  CFRunLoopRun();
+
+  return 0;
+}
+
+// CHECK: global = 42
+// CHECK-NOT: WARNING: ThreadSanitizer

test/tsan/Darwin/gcd-source-event.mm

+// RUN: %clang_tsan %s -o %t -framework Foundation
+// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+
+#import <Foundation/Foundation.h>
+
+long global;
+
+int main(int argc, const char *argv[]) {
+  dispatch_queue_t queue =
+      dispatch_queue_create("my.queue", DISPATCH_QUEUE_CONCURRENT);
+
+  dispatch_source_t source =
+      dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
+
+  dispatch_source_set_timer(source, dispatch_walltime(NULL, 0), 1e9, 5);
+
+  global = 42;
+
+  dispatch_source_set_event_handler(source, ^{
+    fprintf(stderr, "global = %ld\n", global);
+
+    dispatch_sync(dispatch_get_main_queue(), ^{
+      CFRunLoopStop(CFRunLoopGetCurrent());
+    });
+  });
+
+  dispatch_resume(source);
+
+  CFRunLoopRun();
+
+  return 0;
+}
+
+// CHECK: global = 42
+// CHECK-NOT: WARNING: ThreadSanitizer

test/tsan/Darwin/gcd-source-event2.mm

+// RUN: %clang_tsan %s -o %t -framework Foundation
+// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+
+#import <Foundation/Foundation.h>
+
+long global;
+
+void handler(void *arg) {
+  fprintf(stderr, "global = %ld\n", global);
+
+  dispatch_sync(dispatch_get_main_queue(), ^{
+    CFRunLoopStop(CFRunLoopGetCurrent());
+  });
+}
+
+int main(int argc, const char *argv[]) {
+  dispatch_queue_t queue =
+      dispatch_queue_create("my.queue", DISPATCH_QUEUE_CONCURRENT);
+
+  dispatch_source_t source =
+      dispatch_source_create(DISPATCH_SOURCE_TYPE_TIMER, 0, 0, queue);
+
+  dispatch_source_set_timer(source, dispatch_walltime(NULL, 0), 1e9, 5);
+
+  global = 42;
+
+  dispatch_source_set_event_handler_f(source, &handler);
+
+  dispatch_resume(source);
+
+  CFRunLoopRun();
+
+  return 0;
+}
+
+// CHECK: global = 42
+// CHECK-NOT: WARNING: ThreadSanitizer

test/tsan/Darwin/gcd-source-registration.mm

+// RUN: %clang_tsan %s -o %t -framework Foundation
+// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+
+#import <Foundation/Foundation.h>
+
+long global;
+
+int main(int argc, const char *argv[]) {
+  dispatch_queue_t queue =
+      dispatch_queue_create("my.queue", DISPATCH_QUEUE_CONCURRENT);
+
+  dispatch_source_t source =
+      dispatch_source_create(DISPATCH_SOURCE_TYPE_SIGNAL, SIGHUP, 0, queue);
+
+  global = 42;
+
+  dispatch_source_set_registration_handler(source, ^{
+    fprintf(stderr, "global = %ld\n", global);
+
+    dispatch_sync(dispatch_get_main_queue(), ^{
+      CFRunLoopStop(CFRunLoopGetCurrent());
+    });
+  });
+
+  dispatch_resume(source);
+
+  CFRunLoopRun();
+
+  return 0;
+}
+
+// CHECK: global = 42
+// CHECK-NOT: WARNING: ThreadSanitizer

test/tsan/Darwin/gcd-source-registration2.mm

+// RUN: %clang_tsan %s -o %t -framework Foundation
+// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1 | FileCheck %s
+
+#import <Foundation/Foundation.h>
+
+long global;
+
+void handler(void *arg) {
+  fprintf(stderr, "global = %ld\n", global);
+
+  dispatch_sync(dispatch_get_main_queue(), ^{
+    CFRunLoopStop(CFRunLoopGetCurrent());
+  });
+}
+
+int main(int argc, const char *argv[]) {
+  dispatch_queue_t queue =
+      dispatch_queue_create("my.queue", DISPATCH_QUEUE_CONCURRENT);
+
+  dispatch_source_t source =
+      dispatch_source_create(DISPATCH_SOURCE_TYPE_SIGNAL, SIGHUP, 0, queue);
+
+  global = 42;
+
+  dispatch_source_set_registration_handler_f(source, handler);
+
+  dispatch_resume(source);
+
+  CFRunLoopRun();
+
+  return 0;
+}
+
+// CHECK: global = 42
+// CHECK-NOT: WARNING: ThreadSanitizer