tsan: intercept epoll_pwait2

[dvyukov]

Summary

It's a new syscall similar to epoll_pwait.
Add a similar interceptor for it and add synchronization
annotations in epoll_wait* syscall wrappers.
Testing this is problematic b/c it's not present in glibc
and the syscall itself may not be supported by the kernel.

compiler-rt/lib/sanitizer_common/sanitizer_common_syscalls.inc

 }
 
 PRE_SYSCALL(epoll_wait)
 (long epfd, void *events, long maxevents, long timeout) {}
 
 POST_SYSCALL(epoll_wait)
 (long res, long epfd, void *events, long maxevents, long timeout) {
   if (res >= 0) {
+    COMMON_SYSCALL_FD_ACQUIRE(epfd);
     if (events)
       POST_WRITE(events, res * struct_epoll_event_sz);
   }
 }
 
 PRE_SYSCALL(epoll_pwait)
 (long epfd, void *events, long maxevents, long timeout,
  const kernel_sigset_t *sigmask, long sigsetsize) {
   if (sigmask)
     PRE_READ(sigmask, sigsetsize);
 }
 
 POST_SYSCALL(epoll_pwait)
 (long res, long epfd, void *events, long maxevents, long timeout,
  const void *sigmask, long sigsetsize) {
   if (res >= 0) {
+    COMMON_SYSCALL_FD_ACQUIRE(epfd);
     if (events)
       POST_WRITE(events, res * struct_epoll_event_sz);
   }
 }
 
 PRE_SYSCALL(epoll_pwait2)
 (long epfd, void *events, long maxevents,
  const sanitizer_kernel_timespec *timeout, const kernel_sigset_t *sigmask,
  long sigsetsize) {
   if (timeout)
     PRE_READ(timeout, sizeof(timeout));
   if (sigmask)
     PRE_READ(sigmask, sigsetsize);
 }
 
 POST_SYSCALL(epoll_pwait2)
 (long res, long epfd, void *events, long maxevents,
  const sanitizer_kernel_timespec *timeout, const void *sigmask,
  long sigsetsize) {
   if (res >= 0) {
+    COMMON_SYSCALL_FD_ACQUIRE(epfd);
     if (events)
       POST_WRITE(events, res * struct_epoll_event_sz);
   }
 }
 
 PRE_SYSCALL(gethostname)(void *name, long len) {}
 
 POST_SYSCALL(gethostname)(long res, void *name, long len) {

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

TSAN_INTERCEPTOR(int, epoll_pwait, int epfd, void *ev, int cnt, int timeout,
   if (epfd >= 0)
     FdAccess(thr, pc, epfd);
   int res = BLOCK_REAL(epoll_pwait)(epfd, ev, cnt, timeout, sigmask);
   if (res > 0 && epfd >= 0)
     FdAcquire(thr, pc, epfd);
   return res;
 }
 
-#define TSAN_MAYBE_INTERCEPT_EPOLL \
-    TSAN_INTERCEPT(epoll_create); \
-    TSAN_INTERCEPT(epoll_create1); \
-    TSAN_INTERCEPT(epoll_ctl); \
-    TSAN_INTERCEPT(epoll_wait); \
-    TSAN_INTERCEPT(epoll_pwait)
+TSAN_INTERCEPTOR(int, epoll_pwait2, int epfd, void *ev, int cnt, void *timeout,
+                 void *sigmask) {
+  SCOPED_TSAN_INTERCEPTOR(epoll_pwait2, epfd, ev, cnt, timeout, sigmask);
+  if (epfd >= 0)
+    FdAccess(thr, pc, epfd);
+  int res = BLOCK_REAL(epoll_pwait2)(epfd, ev, cnt, timeout, sigmask);
+  if (res > 0 && epfd >= 0)
+    FdAcquire(thr, pc, epfd);
+  return res;
+}
+
+#  define TSAN_MAYBE_INTERCEPT_EPOLL \
+    TSAN_INTERCEPT(epoll_create);    \
+    TSAN_INTERCEPT(epoll_create1);   \
+    TSAN_INTERCEPT(epoll_ctl);       \
+    TSAN_INTERCEPT(epoll_wait);      \
+    TSAN_INTERCEPT(epoll_pwait);     \
+    TSAN_INTERCEPT(epoll_pwait2)
 #else
 #define TSAN_MAYBE_INTERCEPT_EPOLL
 #endif
 
 // The following functions are intercepted merely to process pending signals.
 // If program blocks signal X, we must deliver the signal before the function
 // returns. Similarly, if program unblocks a signal (or returns from sigsuspend)
 // it's better to deliver the signal straight away.