[Sanitizer] Intercepts flopen/flopenat

[vitalybuka]

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc

10057

maybe move it close to fopen?

10079

why do you need to define macro which used just one time? we use IMPL only for stuff which can be reused.
Could you please inline them as __xuname above?

compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp

654

unrelated, could you please land in a separate patch, OK without review

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc

     CIMT_FILE
   } type;
   union {
     FileMetadata file;
   };
 };
 
 #if SI_POSIX
 typedef AddrHashMap<CommonInterceptorMetadata, 31051> MetadataHashMap;
 
 static MetadataHashMap *interceptor_metadata_map;
 
 UNUSED static void SetInterceptorMetadata(__sanitizer_FILE *addr,
                                           const FileMetadata &file) {
   MetadataHashMap::Handle h(interceptor_metadata_map, (uptr)addr);
   CHECK(h.created());
   h->type = CommonInterceptorMetadata::CIMT_FILE;
   h->file = file;
 }
 
 UNUSED static const FileMetadata *GetInterceptorMetadata(
     __sanitizer_FILE *addr) {

 
 UNUSED static void DeleteInterceptorMetadata(void *addr) {
   MetadataHashMap::Handle h(interceptor_metadata_map, (uptr)addr, true);
   CHECK(h.exists());
 }
 #endif  // SI_POSIX
 
 #if SANITIZER_INTERCEPT_STRLEN
 INTERCEPTOR(SIZE_T, strlen, const char *s) {
   // Sometimes strlen is called prior to InitializeCommonInterceptors,
   // in which case the REAL(strlen) typically used in
   // COMMON_INTERCEPTOR_ENTER will fail.  We use internal_strlen here
   // to handle that.
   if (COMMON_INTERCEPTOR_NOTHING_IS_INITIALIZED)
     return internal_strlen(s);
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, strlen, s);
   SIZE_T result = REAL(strlen)(s);
   if (common_flags()->intercept_strlen)
     COMMON_INTERCEPTOR_READ_RANGE(ctx, s, result + 1);
   return result;
 }
 #define INIT_STRLEN COMMON_INTERCEPT_FUNCTION(strlen)
 #else
 #define INIT_STRLEN
 #endif
 
 #if SANITIZER_INTERCEPT_STRNLEN
 INTERCEPTOR(SIZE_T, strnlen, const char *s, SIZE_T maxlen) {
   void *ctx;
   COMMON_INTERCEPTOR_ENTER(ctx, strnlen, s, maxlen);
   SIZE_T length = REAL(strnlen)(s, maxlen);
   if (common_flags()->intercept_strlen)
     COMMON_INTERCEPTOR_READ_RANGE(ctx, s, Min(length + 1, maxlen));
   return length;
 }
 #define INIT_STRNLEN COMMON_INTERCEPT_FUNCTION(strnlen)
 #else
 #define INIT_STRNLEN
 #endif
 
 #if SANITIZER_INTERCEPT_STRNDUP
 INTERCEPTOR(char*, strndup, const char *s, uptr size) {
   void *ctx;
   COMMON_INTERCEPTOR_STRNDUP_IMPL(ctx, s, size);
 }
 #define INIT_STRNDUP COMMON_INTERCEPT_FUNCTION(strndup)
 #else
 #define INIT_STRNDUP
 #endif // SANITIZER_INTERCEPT_STRNDUP
 

                                    __sanitizer::struct_utsname_sz);
   return res;
 }
 #define INIT___XUNAME COMMON_INTERCEPT_FUNCTION(__xuname)
 #else
 #define INIT___XUNAME
 #endif
 
+#if SANITIZER_INTERCEPT_FLOPEN
+#define FLOPEN_INTERCEPTOR_IMPL(flopen, path, flags, ...)                      \
+  {                                                                            \
+    void *ctx;                                                                 \
+    COMMON_INTERCEPTOR_ENTER(ctx, flopen, path, flags, ##__VA_ARGS__);         \
+    if (path) {                                                                \
+        COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);      \
+    }                                                                          \
+    return REAL(flopen)(path, flags, ##__VA_ARGS__);                           \
+  }
+
+#define FLOPENAT_INTERCEPTOR_IMPL(flopenat, dirfd, path, flags, ...)           \
+  {                                                                            \
+    void *ctx;                                                                 \
+    COMMON_INTERCEPTOR_ENTER(ctx, flopenat, dirfd, path, flags, ##__VA_ARGS__);\
+    if (path) {                                                                \
+        COMMON_INTERCEPTOR_READ_RANGE(ctx, path, REAL(strlen)(path) + 1);      \
+    }                                                                          \
+    return REAL(flopenat)(dirfd, path, flags, ##__VA_ARGS__);                  \
+  }
+
+INTERCEPTOR(int, flopen, char *path, int flags) {
+  FLOPEN_INTERCEPTOR_IMPL(flopen, path, flags);
+}
+
+INTERCEPTOR(int, flopenat, int dirfd, char *path, int flags) {
+  FLOPENAT_INTERCEPTOR_IMPL(flopenat, dirfd, path, flags);
+}
+
+#define INIT_FLOPEN    \
+  COMMON_INTERCEPT_FUNCTION(flopen); \
+  COMMON_INTERCEPT_FUNCTION(flopenat);
+#else
+#define INIT_FLOPEN
+#endif
+
 #include "sanitizer_common_interceptors_netbsd_compat.inc"
 
 static void InitializeCommonInterceptors() {
 #if SI_POSIX
   static u64 metadata_mem[sizeof(MetadataHashMap) / sizeof(u64) + 1];
   interceptor_metadata_map = new ((void *)&metadata_mem) MetadataHashMap();
 #endif
 

   INIT_CRYPT;
   INIT_CRYPT_R;
   INIT_GETENTROPY;
   INIT_QSORT;
   INIT_QSORT_R;
   INIT_SIGALTSTACK;
   INIT_UNAME;
   INIT___XUNAME;
+  INIT_FLOPEN;
 
   INIT___PRINTF_CHK;
 }

compiler-rt/lib/sanitizer_common/sanitizer_linux.cpp

#    elif SANITIZER_NETBSD
   sched_yield();   /* No userspace futex-like synchronization */
 #    else
   internal_syscall(SYSCALL(futex), (uptr)p, FUTEX_WAIT_PRIVATE, cmp, 0, 0, 0);
 #    endif
 }
 
 void FutexWake(atomic_uint32_t *p, u32 count) {
 #    if SANITIZER_FREEBSD
-  _umtx_op(p_, UMTX_OP_WAKE, count, 0, 0);
+  _umtx_op(p, UMTX_OP_WAKE, count, 0, 0);
 #    elif SANITIZER_NETBSD
                    /* No userspace futex-like synchronization */
 #    else
   internal_syscall(SYSCALL(futex), (uptr)p, FUTEX_WAKE_PRIVATE, count, 0, 0, 0);
 #    endif
 }
 
 enum { MtxUnlocked = 0, MtxLocked = 1, MtxSleeping = 2 };

compiler-rt/lib/sanitizer_common/sanitizer_platform_interceptors.h

#define SANITIZER_INTERCEPT_QSORT \
   (SI_POSIX && !SI_IOSSIM && !SI_WATCHOS && !SI_TVOS && !SI_ANDROID)
 #define SANITIZER_INTERCEPT_QSORT_R SI_GLIBC
 // sigaltstack on i386 macOS cannot be intercepted due to setjmp()
 // calling it and assuming that it does not clobber registers.
 #define SANITIZER_INTERCEPT_SIGALTSTACK \
   (SI_POSIX && !(SANITIZER_MAC && SANITIZER_I386))
 #define SANITIZER_INTERCEPT_UNAME (SI_POSIX && !SI_FREEBSD)
 #define SANITIZER_INTERCEPT___XUNAME SI_FREEBSD
+#define SANITIZER_INTERCEPT_FLOPEN SI_FREEBSD
 
 // This macro gives a way for downstream users to override the above
 // interceptor macros irrespective of the platform they are on. They have
 // to do two things:
 // 1. Build compiler-rt with -DSANITIZER_OVERRIDE_INTERCEPTORS.
 // 2. Provide a header file named sanitizer_intercept_overriders.h in the
 //    include path for their compiler-rt build.
 // An example of an overrider for strlen interceptor that one can list in

compiler-rt/test/sanitizer_common/TestCases/FreeBSD/flopen.cc

+// RUN: %clangxx -O0 -g %s -o %t -lutil && %run %t 2>&1 | FileCheck %s
+
+#include <sys/fcntl.h>
+#include <assert.h>
+#include <stdlib.h>
+#include <libutil.h>
+
+int main(void) {
+  char buf[256];
+  arc4random_buf(buf, sizeof(buf));
+  int fd = flopen(nullptr, 0, 0);
+  assert(fd == -1);
+  fd = flopen("/TMP", O_RDONLY, 0600);
+  assert(fd == -1);
+  int dirfd = open("/tmp", O_CLOEXEC | O_DIRECTORY);
+  assert(dirfd != -1);
+  fd = flopenat(dirfd, buf, O_RDONLY, 0666);
+  assert(fd == -1);
+  return 0;
+}