[sanitizer] Move *fstat to the common interceptors

[zhaoqin]

Summary

Adds *fstat to the common interceptors.

Removes the now-duplicate fstat interceptor from msan/tsan
This adds fstat to asan/esan, which previously did not intercept it.

Resubmit of http://reviews.llvm.org/D20318 with ios build fixes.

[aizatsky]

Qin, what has changed for ios? I can't spot a difference.

[zhaoqin]

lib/sanitizer_common/sanitizer_platform_interceptors.h

310 ↗

(On Diff #57558)

The changes are the above three lines, I use the same define as _STAT, ___XSTAT, and ___XSTAT64

in http://reviews.llvm.org/D20318, it was
#define SANITIZER_INTERCEPT_FSTATAT SI_FREEBSD
#define SANITIZER_INTERCEPT___FXSTATAT !SI_FREEBSD && SI_NOT_WINDOWS
#define SANITIZER_INTERCEPT___FXSTATAT64 !SI_FREEBSD && SI_NOT_WINDOWS

[aizatsky]

I'll commit.

[zhaoqin]

Thanks and hope no bot broken (finger crossed).

compiler-rt/trunk/lib/asan/asan_interceptors.cc

#define COMMON_INTERCEPTOR_DIR_ACQUIRE(ctx, path) \
   do {                                            \
   } while (false)
 #define COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd) \
   do {                                         \
   } while (false)
 #define COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd) \
   do {                                         \
   } while (false)
+#define COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd) \
+  do {                                        \
+  } while (false)
 #define COMMON_INTERCEPTOR_FD_SOCKET_ACCEPT(ctx, fd, newfd) \
   do {                                                      \
   } while (false)
 #define COMMON_INTERCEPTOR_SET_THREAD_NAME(ctx, name) SetThreadName(name)
 // Should be asanThreadRegistry().SetThreadNameByUserId(thread, name)
 // But asan does not remember UserId's for threads (pthread_t);
 // and remembers all ever existed threads, so the linear search by UserId
 // can be slow.

compiler-rt/trunk/lib/msan/msan_interceptors.cc

 
 INTERCEPTOR(int, putenv, char *string) {
   ENSURE_MSAN_INITED();
   int res = REAL(putenv)(string);
   if (!res) UnpoisonEnviron();
   return res;
 }
 
-#if !SANITIZER_FREEBSD
-INTERCEPTOR(int, __fxstat, int magic, int fd, void *buf) {
-  ENSURE_MSAN_INITED();
-  int res = REAL(__fxstat)(magic, fd, buf);
-  if (!res)
-    __msan_unpoison(buf, __sanitizer::struct_stat_sz);
-  return res;
-}
-#define MSAN_MAYBE_INTERCEPT___FXSTAT INTERCEPT_FUNCTION(__fxstat)
-#else
-#define MSAN_MAYBE_INTERCEPT___FXSTAT
-#endif
-
-#if !SANITIZER_FREEBSD
-INTERCEPTOR(int, __fxstat64, int magic, int fd, void *buf) {
-  ENSURE_MSAN_INITED();
-  int res = REAL(__fxstat64)(magic, fd, buf);
-  if (!res)
-    __msan_unpoison(buf, __sanitizer::struct_stat64_sz);
-  return res;
-}
-#define MSAN_MAYBE_INTERCEPT___FXSTAT64 INTERCEPT_FUNCTION(__fxstat64)
-#else
-#define MSAN_MAYBE_INTERCEPT___FXSTAT64
-#endif
-
-#if SANITIZER_FREEBSD
-INTERCEPTOR(int, fstatat, int fd, char *pathname, void *buf, int flags) {
-  ENSURE_MSAN_INITED();
-  int res = REAL(fstatat)(fd, pathname, buf, flags);
-  if (!res) __msan_unpoison(buf, __sanitizer::struct_stat_sz);
-  return res;
-}
-# define MSAN_INTERCEPT_FSTATAT INTERCEPT_FUNCTION(fstatat)
-#else
-INTERCEPTOR(int, __fxstatat, int magic, int fd, char *pathname, void *buf,
-            int flags) {
-  ENSURE_MSAN_INITED();
-  int res = REAL(__fxstatat)(magic, fd, pathname, buf, flags);
-  if (!res) __msan_unpoison(buf, __sanitizer::struct_stat_sz);
-  return res;
-}
-# define MSAN_INTERCEPT_FSTATAT INTERCEPT_FUNCTION(__fxstatat)
-#endif
-
-#if !SANITIZER_FREEBSD
-INTERCEPTOR(int, __fxstatat64, int magic, int fd, char *pathname, void *buf,
-            int flags) {
-  ENSURE_MSAN_INITED();
-  int res = REAL(__fxstatat64)(magic, fd, pathname, buf, flags);
-  if (!res) __msan_unpoison(buf, __sanitizer::struct_stat64_sz);
-  return res;
-}
-#define MSAN_MAYBE_INTERCEPT___FXSTATAT64 INTERCEPT_FUNCTION(__fxstatat64)
-#else
-#define MSAN_MAYBE_INTERCEPT___FXSTATAT64
-#endif
-
 INTERCEPTOR(int, pipe, int pipefd[2]) {
   if (msan_init_is_running)
     return REAL(pipe)(pipefd);
   ENSURE_MSAN_INITED();
   int res = REAL(pipe)(pipefd);
   if (!res)
     __msan_unpoison(pipefd, sizeof(int[2]));
   return res;
#define COMMON_INTERCEPTOR_DIR_ACQUIRE(ctx, path) \
   do {                                            \
   } while (false)
 #define COMMON_INTERCEPTOR_FD_ACQUIRE(ctx, fd) \
   do {                                         \
   } while (false)
 #define COMMON_INTERCEPTOR_FD_RELEASE(ctx, fd) \
   do {                                         \
   } while (false)
+#define COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd) \
+  do {                                        \
+  } while (false)
 #define COMMON_INTERCEPTOR_FD_SOCKET_ACCEPT(ctx, fd, newfd) \
   do {                                                      \
   } while (false)
 #define COMMON_INTERCEPTOR_SET_THREAD_NAME(ctx, name) \
   do {                                                \
   } while (false)  // FIXME
 #define COMMON_INTERCEPTOR_SET_PTHREAD_NAME(ctx, thread, name) \
   do {                                                         \
#endif
   INTERCEPT_FUNCTION(wcschr);
   INTERCEPT_FUNCTION(wcscpy);
   INTERCEPT_FUNCTION(wcscmp);
   INTERCEPT_FUNCTION(getenv);
   INTERCEPT_FUNCTION(setenv);
   INTERCEPT_FUNCTION(putenv);
   INTERCEPT_FUNCTION(gettimeofday);
   INTERCEPT_FUNCTION(fcvt);
-  MSAN_MAYBE_INTERCEPT___FXSTAT;
-  MSAN_INTERCEPT_FSTATAT;
-  MSAN_MAYBE_INTERCEPT___FXSTAT64;
-  MSAN_MAYBE_INTERCEPT___FXSTATAT64;
   INTERCEPT_FUNCTION(pipe);
   INTERCEPT_FUNCTION(pipe2);
   INTERCEPT_FUNCTION(socketpair);
   INTERCEPT_FUNCTION(fgets);
   MSAN_MAYBE_INTERCEPT_FGETS_UNLOCKED;
   INTERCEPT_FUNCTION(getrlimit);
   MSAN_MAYBE_INTERCEPT_GETRLIMIT64;
   MSAN_MAYBE_INTERCEPT_PRLIMIT;

compiler-rt/trunk/lib/sanitizer_common/sanitizer_common_interceptors.inc

if (!res)
     COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, __sanitizer::struct_stat64_sz);
   return res;
 }
 #define INIT___LXSTAT64 COMMON_INTERCEPT_FUNCTION(__lxstat64)
 #else
 #define INIT___LXSTAT64
 #endif
 
-// FIXME: add other *stat interceptor
+#if SANITIZER_INTERCEPT_FSTAT
+INTERCEPTOR(int, fstat, int fd, void *buf) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, fstat, fd, buf);
+  if (common_flags()->intercept_stat && fd > 0)
+    COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
+  int res = REAL(fstat)(fd, buf);
+  if (!res)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, __sanitizer::struct_stat_sz);
+  return res;
+}
+#define INIT_FSTAT COMMON_INTERCEPT_FUNCTION(fstat)
+#else
+#define INIT_FSTAT
+#endif
+
+#if SANITIZER_INTERCEPT___FXSTAT
+INTERCEPTOR(int, __fxstat, int version, int fd, void *buf) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, __fxstat, version, fd, buf);
+  if (common_flags()->intercept_stat && fd > 0)
+    COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
+  int res = REAL(__fxstat)(version, fd, buf);
+  if (!res)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, __sanitizer::struct_stat_sz);
+  return res;
+}
+#define INIT___FXSTAT COMMON_INTERCEPT_FUNCTION(__fxstat)
+#else
+#define INIT___FXSTAT
+#endif
+
+#if SANITIZER_INTERCEPT___FXSTAT64
+INTERCEPTOR(int, __fxstat64, int version, int fd, void *buf) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, __fxstat64, version, fd, buf);
+  if (common_flags()->intercept_stat && fd > 0)
+    COMMON_INTERCEPTOR_FD_ACCESS(ctx, fd);
+  int res = REAL(__fxstat64)(version, fd, buf);
+  if (!res)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, __sanitizer::struct_stat64_sz);
+  return res;
+}
+#define INIT___FXSTAT64 COMMON_INTERCEPT_FUNCTION(__fxstat64)
+#else
+#define INIT___FXSTAT64
+#endif
+
+#if SANITIZER_INTERCEPT_FSTATAT
+INTERCEPTOR(int, fstatat, int fd, char *pathname, void *buf, int flags) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, fstatat, fd, pathname, buf, flags);
+  if (common_flags()->intercept_stat)
+    COMMON_INTERCEPTOR_READ_STRING(ctx, pathname, 0);
+  int res = REAL(fstatat)(fd, pathname, buf, flags);
+  if (!res)
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, __sanitizer::struct_stat_sz);
+  return res;
+}
+#define INIT_FSTATAT COMMON_INTERCEPT_FUNCTION(fstatat);
+#else
+#define INIT_FSTATAT
+#endif
+
+#if SANITIZER_INTERCEPT___FXSTATAT
+INTERCEPTOR(int, __fxstatat, int version, int fd, char *pathname, void *buf,
+            int flags) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, __fxstatat, version, fd, pathname, buf, flags);
+  if (common_flags()->intercept_stat)
+    COMMON_INTERCEPTOR_READ_STRING(ctx, pathname, 0);
+  int res = REAL(__fxstatat)(fd, version, pathname, buf, flags);
+  if (!res) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, __sanitizer::struct_stat_sz);
+  }
+  return res;
+}
+#define INIT___FXSTATAT COMMON_INTERCEPT_FUNCTION(__fxstatat);
+#else
+#define INIT___FXSTATAT
+#endif
+
+#if SANITIZER_INTERCEPT___FXSTATAT64
+INTERCEPTOR(int, __fxstatat64, int version, int fd, char *pathname, void *buf,
+            int flags) {
+  void *ctx;
+  COMMON_INTERCEPTOR_ENTER(ctx, __fxstatat64, version, fd, pathname, buf,
+                           flags);
+  if (common_flags()->intercept_stat)
+    COMMON_INTERCEPTOR_READ_STRING(ctx, pathname, 0);
+  int res = REAL(__fxstatat64)(fd, version, pathname, buf, flags);
+  if (!res) {
+    COMMON_INTERCEPTOR_WRITE_RANGE(ctx, buf, __sanitizer::struct_stat64_sz);
+  }
+  return res;
+}
+#define INIT___FXSTATAT64 COMMON_INTERCEPT_FUNCTION(__fxstatat64);
+#else
+#define INIT___FXSTATAT64
+#endif
 
 static void InitializeCommonInterceptors() {
   static u64 metadata_mem[sizeof(MetadataHashMap) / sizeof(u64) + 1];
   interceptor_metadata_map = new((void *)&metadata_mem) MetadataHashMap();
 
   INIT_TEXTDOMAIN;
   INIT_STRLEN;
   INIT_STRNLEN;
static void InitializeCommonInterceptors() {
   INIT_CTERMID;
   INIT_CTERMID_R;
   INIT_RECV_RECVFROM;
   INIT_STAT;
   INIT___XSTAT;
   INIT___XSTAT64;
   INIT___LXSTAT;
   INIT___LXSTAT64;
-  // FIXME: add other *stat interceptors.
+  INIT_FSTAT;
+  INIT___FXSTAT;
+  INIT___FXSTAT64;
+  INIT_FSTATAT;
+  INIT___FXSTATAT;
+  INIT___FXSTATAT64;
 }

compiler-rt/trunk/lib/sanitizer_common/sanitizer_platform_interceptors.h

 #define SANITIZER_INTERCEPTOR_HOOKS SI_LINUX
 #define SANITIZER_INTERCEPT_RECV_RECVFROM SI_NOT_WINDOWS
 
 #define SANITIZER_INTERCEPT_STAT (SI_FREEBSD || SI_MAC || SI_ANDROID)
 #define SANITIZER_INTERCEPT___XSTAT !SANITIZER_INTERCEPT_STAT && SI_NOT_WINDOWS
 #define SANITIZER_INTERCEPT___XSTAT64 SI_LINUX_NOT_ANDROID
 #define SANITIZER_INTERCEPT___LXSTAT SANITIZER_INTERCEPT___XSTAT
 #define SANITIZER_INTERCEPT___LXSTAT64 SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_FSTAT SANITIZER_INTERCEPT_STAT
+#define SANITIZER_INTERCEPT___FXSTAT SANITIZER_INTERCEPT___XSTAT
+#define SANITIZER_INTERCEPT___FXSTAT64 SI_LINUX_NOT_ANDROID
+#define SANITIZER_INTERCEPT_FSTATAT SI_FREEBSD
+#define SANITIZER_INTERCEPT___FXSTATAT SANITIZER_INTERCEPT___XSTAT
+#define SANITIZER_INTERCEPT___FXSTATAT64 SI_LINUX_NOT_ANDROID
 #endif  // #ifndef SANITIZER_PLATFORM_INTERCEPTORS_H

compiler-rt/trunk/lib/tsan/rtl/tsan_interceptors.cc

while (v != 2) {
       v = atomic_load(a, memory_order_acquire);
     }
     if (!thr->in_ignored_lib)
       Acquire(thr, pc, (uptr)o);
   }
   return 0;
 }
 
-#if SANITIZER_LINUX && !SANITIZER_ANDROID
-TSAN_INTERCEPTOR(int, __fxstat, int version, int fd, void *buf) {
-  SCOPED_TSAN_INTERCEPTOR(__fxstat, version, fd, buf);
-  if (fd > 0)
-    FdAccess(thr, pc, fd);
-  return REAL(__fxstat)(version, fd, buf);
-}
-#define TSAN_MAYBE_INTERCEPT___FXSTAT TSAN_INTERCEPT(__fxstat)
-#else
-#define TSAN_MAYBE_INTERCEPT___FXSTAT
-#endif
-
-TSAN_INTERCEPTOR(int, fstat, int fd, void *buf) {
-#if SANITIZER_FREEBSD || SANITIZER_MAC || SANITIZER_ANDROID
-  SCOPED_TSAN_INTERCEPTOR(fstat, fd, buf);
-  if (fd > 0)
-    FdAccess(thr, pc, fd);
-  return REAL(fstat)(fd, buf);
-#else
-  SCOPED_TSAN_INTERCEPTOR(__fxstat, 0, fd, buf);
-  if (fd > 0)
-    FdAccess(thr, pc, fd);
-  return REAL(__fxstat)(0, fd, buf);
-#endif
-}
-
-#if SANITIZER_LINUX && !SANITIZER_ANDROID
-TSAN_INTERCEPTOR(int, __fxstat64, int version, int fd, void *buf) {
-  SCOPED_TSAN_INTERCEPTOR(__fxstat64, version, fd, buf);
-  if (fd > 0)
-    FdAccess(thr, pc, fd);
-  return REAL(__fxstat64)(version, fd, buf);
-}
-#define TSAN_MAYBE_INTERCEPT___FXSTAT64 TSAN_INTERCEPT(__fxstat64)
-#else
-#define TSAN_MAYBE_INTERCEPT___FXSTAT64
-#endif
-
-#if SANITIZER_LINUX && !SANITIZER_ANDROID
-TSAN_INTERCEPTOR(int, fstat64, int fd, void *buf) {
-  SCOPED_TSAN_INTERCEPTOR(__fxstat64, 0, fd, buf);
-  if (fd > 0)
-    FdAccess(thr, pc, fd);
-  return REAL(__fxstat64)(0, fd, buf);
-}
-#define TSAN_MAYBE_INTERCEPT_FSTAT64 TSAN_INTERCEPT(fstat64)
-#else
-#define TSAN_MAYBE_INTERCEPT_FSTAT64
-#endif
-
 TSAN_INTERCEPTOR(int, open, const char *name, int flags, int mode) {
   SCOPED_TSAN_INTERCEPTOR(open, name, flags, mode);
   READ_STRING(thr, pc, name, 0);
   int fd = REAL(open)(name, flags, mode);
   if (fd >= 0)
     FdFileCreate(thr, pc, fd);
   return fd;
 }
#endif
   TSAN_INTERCEPT(pthread_rwlock_unlock);
 
   TSAN_INTERCEPT(pthread_barrier_init);
   TSAN_INTERCEPT(pthread_barrier_destroy);
   TSAN_INTERCEPT(pthread_barrier_wait);
 
   TSAN_INTERCEPT(pthread_once);
 
-  TSAN_INTERCEPT(fstat);
-  TSAN_MAYBE_INTERCEPT___FXSTAT;
-  TSAN_MAYBE_INTERCEPT_FSTAT64;
-  TSAN_MAYBE_INTERCEPT___FXSTAT64;
   TSAN_INTERCEPT(open);
   TSAN_MAYBE_INTERCEPT_OPEN64;
   TSAN_INTERCEPT(creat);
   TSAN_MAYBE_INTERCEPT_CREAT64;
   TSAN_INTERCEPT(dup);
   TSAN_INTERCEPT(dup2);
   TSAN_INTERCEPT(dup3);
   TSAN_MAYBE_INTERCEPT_EVENTFD;