[tsan] Add XPC support (OS X)

[kubamracek]

Summary

XPC APIs have async callbacks, and we need some more happen-before edges to avoid false positives. This patch add them, plus a test case (sorry for the long boilerplate code, but XPC just needs all that).

[kubamracek]

Adding a second test case that actually has a race in it.

[dvyukov]

lib/tsan/rtl/tsan_interceptors_mac.cc

133

add some spaces before the line
or is it clang-format formatted?

[kubamracek]

lib/tsan/rtl/tsan_interceptors_mac.cc

133

It's clang-format. It has hard times with REAL(x)(y) in general.

[dvyukov]

lib/tsan/rtl/tsan_interceptors_mac.cc

133

ack

lib/tsan/rtl/tsan_interceptors_mac.cc

 
 #include "sanitizer_common/sanitizer_platform.h"
 #if SANITIZER_MAC
 
 #include "interception/interception.h"
 #include "tsan_interceptors.h"
 
 #include <libkern/OSAtomic.h>
+#include <xpc/xpc.h>
 
 namespace __tsan {
 
 TSAN_INTERCEPTOR(void, OSSpinLockLock, volatile OSSpinLock *lock) {
   CHECK(!cur_thread()->is_dead);
   if (!cur_thread()->is_inited) {
     return REAL(OSSpinLockLock)(lock);
   }
TSAN_INTERCEPTOR(void, os_lock_unlock, void *lock) {
   if (!cur_thread()->is_inited) {
     return REAL(os_lock_unlock)(lock);
   }
   SCOPED_TSAN_INTERCEPTOR(os_lock_unlock, lock);
   Release(thr, pc, (uptr)lock);
   REAL(os_lock_unlock)(lock);
 }
 
+TSAN_INTERCEPTOR(void, xpc_connection_set_event_handler,
+                 xpc_connection_t connection, xpc_handler_t handler) {
+  SCOPED_TSAN_INTERCEPTOR(xpc_connection_set_event_handler, connection,
+                          handler);
+  Release(thr, pc, (uptr)connection);
+  xpc_handler_t new_handler = ^(xpc_object_t object) {
+    SCOPED_INTERCEPTOR_RAW(xpc_connection_set_event_handler);
+    Acquire(thr, pc, (uptr)connection);
+    handler(object);
+  };
+  REAL(xpc_connection_set_event_handler)(connection, new_handler);
+}
+
+TSAN_INTERCEPTOR(void, xpc_connection_send_barrier, xpc_connection_t connection,
+                 dispatch_block_t barrier) {
+  SCOPED_TSAN_INTERCEPTOR(xpc_connection_send_barrier, connection, barrier);
+  Release(thr, pc, (uptr)connection);
+  dispatch_block_t new_barrier = ^() {
+    SCOPED_INTERCEPTOR_RAW(xpc_connection_send_barrier);
+    Acquire(thr, pc, (uptr)connection);
+    barrier();
+  };
+  REAL(xpc_connection_send_barrier)(connection, new_barrier);
+}
+
+TSAN_INTERCEPTOR(void, xpc_connection_send_message_with_reply,
+                 xpc_connection_t connection, xpc_object_t message,
+                 dispatch_queue_t replyq, xpc_handler_t handler) {
+  SCOPED_TSAN_INTERCEPTOR(xpc_connection_send_message_with_reply, connection,
+                          message, replyq, handler);
+  Release(thr, pc, (uptr)connection);
+  xpc_handler_t new_handler = ^(xpc_object_t object) {
+    SCOPED_INTERCEPTOR_RAW(xpc_connection_send_message_with_reply);
+    Acquire(thr, pc, (uptr)connection);
+    handler(object);
+  };
+  REAL(xpc_connection_send_message_with_reply)
+  (connection, message, replyq, new_handler);
+}
+
 }  // namespace __tsan
 
 #endif  // SANITIZER_MAC

test/tsan/Darwin/xpc.mm

+// RUN: %clang_tsan %s -o %t -framework Foundation
+// RUN: %env_tsan_opts=ignore_interceptors_accesses=1 %run %t 2>&1
+
+#import <Foundation/Foundation.h>
+
+long global;
+
+int main(int argc, const char * argv[]) {
+    @autoreleasepool {
+        dispatch_queue_t server_q = dispatch_queue_create("server.queue", DISPATCH_QUEUE_CONCURRENT);
+        dispatch_queue_t client_q = dispatch_queue_create("client.queue", DISPATCH_QUEUE_CONCURRENT);
+        
+        xpc_connection_t server_conn = xpc_connection_create(NULL, server_q);
+
+        global = 42;
+
+        xpc_connection_set_event_handler(server_conn, ^(xpc_object_t client) {
+            NSLog(@"global = %ld", global);
+            NSLog(@"server event handler, client = %@", client);
+            
+            if (client == XPC_ERROR_CONNECTION_INTERRUPTED || client == XPC_ERROR_CONNECTION_INVALID) {
+                return;
+            }
+            xpc_connection_set_event_handler( client, ^(xpc_object_t object) {
+                NSLog(@"received message: %@", object);
+                
+                xpc_object_t reply = xpc_dictionary_create_reply( object );
+                if (! reply) return;
+                xpc_dictionary_set_string( reply, "reply", "value" );
+                
+                xpc_connection_t remote = xpc_dictionary_get_remote_connection( object );
+                xpc_connection_send_message( remote, reply );
+            } );
+            
+            xpc_connection_resume( client );
+        });
+        xpc_connection_resume(server_conn);
+        xpc_endpoint_t endpoint = xpc_endpoint_create(server_conn);
+        
+        xpc_connection_t client_conn = xpc_connection_create_from_endpoint(endpoint);
+        xpc_connection_set_event_handler(client_conn, ^(xpc_object_t event) {
+            NSLog(@"client event handler, event = %@", event);
+        });
+        
+        xpc_object_t msg = xpc_dictionary_create(NULL, NULL, 0);
+        xpc_dictionary_set_string(msg, "hello", "world");
+        NSLog(@"sending message: %@", msg);
+        
+        xpc_connection_send_message_with_reply(client_conn, msg, client_q, ^(xpc_object_t object) {
+            NSLog(@"received reply: %@", object);
+
+            xpc_connection_cancel(client_conn);
+            xpc_connection_cancel(server_conn);
+            
+            dispatch_sync(dispatch_get_main_queue(), ^{
+                CFRunLoopStop(CFRunLoopGetCurrent());
+            });
+        });
+        xpc_connection_resume(client_conn);
+        
+        CFRunLoopRun();
+        
+        NSLog(@"Done.");
+    }
+    return 0;
+}
+
+// CHECK: Done.
+// CHECK-NOT: WARNING: ThreadSanitizer