[sanitizers] Fixes strndup API behaviour when intercepted by sanitizers

[kmnls]

Summary

Sanitizers ignore flag allocator_may_return_null=1 in strndup() calls.
When OOM is emulated, this causes to the unexpected crash.

[kmnls]

[sanitizer] Update test, check error, return proper value, print error.

[kmnls]

[sanitizers] Revert testcase code as not related

[kmnls]

@kcc @morehouse @ccross @pgousseau Could you please review this fix.

[pgousseau]

LGTM!

[kmnls]

@pgousseau Would you take some of your valuable time to commit this patch for my behalf, please?

If you make your first contributions to the LLVM infrastructure, you are unlikely to have commit access. In this case, ask the reviewers to commit the change for you after it has been accepted. [DevPolicy]
Prior to obtaining commit access, it is common practice to request that someone with commit access commits on your behalf. When doing so, please provide the name and email address you would like to use in the Author property of the commit. [DevPolicy]

Author property: Kostyantyn Melnik, [e-mail]

[pgousseau]

In D126452#3545936, @kmnls wrote:

@pgousseau Would you take some of your valuable time to commit this patch for my behalf, please?

If you make your first contributions to the LLVM infrastructure, you are unlikely to have commit access. In this case, ask the reviewers to commit the change for you after it has been accepted. [DevPolicy]
Prior to obtaining commit access, it is common practice to request that someone with commit access commits on your behalf. When doing so, please provide the name and email address you would like to use in the Author property of the commit. [DevPolicy]

Author property: Kostyantyn Melnik, [e-mail]

With pleasure, done now!

compiler-rt/lib/sanitizer_common/sanitizer_common_interceptors.inc

 #ifndef COMMON_INTERCEPTOR_STRNDUP_IMPL
 #define COMMON_INTERCEPTOR_STRNDUP_IMPL(ctx, s, size)                         \
   COMMON_INTERCEPTOR_ENTER(ctx, strndup, s, size);                            \
   uptr copy_length = internal_strnlen(s, size);                               \
   char *new_mem = (char *)WRAP(malloc)(copy_length + 1);                      \
   if (common_flags()->intercept_strndup) {                                    \
     COMMON_INTERCEPTOR_READ_STRING(ctx, s, Min(size, copy_length + 1));       \
   }                                                                           \
-  COMMON_INTERCEPTOR_COPY_STRING(ctx, new_mem, s, copy_length);               \
-  internal_memcpy(new_mem, s, copy_length);                                   \
-  new_mem[copy_length] = '\0';                                                \
+  if (new_mem) {                                                              \
+    COMMON_INTERCEPTOR_COPY_STRING(ctx, new_mem, s, copy_length);             \
+    internal_memcpy(new_mem, s, copy_length);                                 \
+    new_mem[copy_length] = '\0';                                              \
+  }                                                                           \
   return new_mem;
 #endif
 
 #ifndef COMMON_INTERCEPTOR_STRERROR
 #define COMMON_INTERCEPTOR_STRERROR() {}
 #endif
 
 struct FileMetadata {

compiler-rt/test/sanitizer_common/TestCases/Linux/decorate_proc_maps.cpp

 // RUN: %clangxx -g %s -o %t
 // RUN: %env_tool_opts=decorate_proc_maps=1 %run %t 2>&1 | FileCheck %s --check-prefix=CHECK-%tool_name
 
 // REQUIRES: stable-runtime
 // XFAIL: android && asan
 
 #include <errno.h>
 #include <fcntl.h>
 #include <pthread.h>
 #include <stdio.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <unistd.h>
 
-bool CopyFdToFd(int in_fd, int out_fd) {
+int CopyFdToFd(int in_fd, int out_fd) {
   const size_t kBufSize = 0x10000;
   static char buf[kBufSize];
   while (true) {
     ssize_t got = read(in_fd, buf, kBufSize);
     if (got > 0) {
       write(out_fd, buf, got);
     } else if (got == 0) {
       break;
     } else if (errno != EAGAIN || errno != EWOULDBLOCK || errno != EINTR) {
       fprintf(stderr, "error reading file, errno %d\n", errno);
-      return false;
+      return 1;
     }
   }
-  return true;
+  return 0;
 }
 
 void *ThreadFn(void *arg) {
   (void)arg;
   int fd = open("/proc/self/maps", O_RDONLY);
-  bool res = CopyFdToFd(fd, 2);
+  if (fd >= 0) {
+    int res = CopyFdToFd(fd, 2);
     close(fd);
-  return (void *)!res;
+    return (void *)res;
+  } else {
+    fprintf(stderr, "error opening file, errno %d\n", errno);
+    return (void*)1;
+  }
 }
 
 int main(void) {
   pthread_t t;
   void *res;
   pthread_create(&t, 0, ThreadFn, 0);
   pthread_join(t, &res);
   return (int)(size_t)res;

compiler-rt/test/sanitizer_common/TestCases/max_allocation_size.cpp

 // Test the behavior of malloc/calloc/realloc/new when the allocation size
 // exceeds the configured max_allocation_size_mb flag.
 // By default (allocator_may_return_null=0) the process should crash. With
 // allocator_may_return_null=1 the allocator should return nullptr and set errno
 // to the appropriate error code.
 //
 // RUN: %clangxx -O0 %s -o %t
 // RUN: %run %t malloc 2>&1 | FileCheck %s --check-prefix=CHECK-NOTNULL

 // RUN:   not %run %t new 2>&1 | FileCheck %s --check-prefix=CHECK-nCRASH
 // RUN: %env_tool_opts=max_allocation_size_mb=2:allocator_may_return_null=1 \
 // RUN:   not %run %t new 2>&1 | FileCheck %s --check-prefix=CHECK-nCRASH-OOM
 // RUN: %env_tool_opts=max_allocation_size_mb=2:allocator_may_return_null=0 \
 // RUN:   not %run %t new-nothrow 2>&1 \
 // RUN:   | FileCheck %s --check-prefix=CHECK-nnCRASH
 // RUN: %env_tool_opts=max_allocation_size_mb=2:allocator_may_return_null=1 \
 // RUN:   %run %t new-nothrow 2>&1 | FileCheck %s --check-prefix=CHECK-NULL
+// RUN: %env_tool_opts=max_allocation_size_mb=2:allocator_may_return_null=0 \
+// RUN:   not %run %t strndup 2>&1 | FileCheck %s --check-prefix=CHECK-sCRASH
+// RUN: %env_tool_opts=max_allocation_size_mb=2:allocator_may_return_null=1 \
+// RUN:   %run %t strndup 2>&1 | FileCheck %s --check-prefix=CHECK-NULL
 
 // win32 is disabled due to failing errno tests.
 // UNSUPPORTED: ubsan, windows-msvc
 
 #include <assert.h>
 #include <errno.h>
 #include <limits>
 #include <new>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
+constexpr size_t MaxAllocationSize = size_t{2} << 20;
+
 static void *allocate(const char *Action, size_t Size) {
   if (!strcmp(Action, "malloc"))
     return malloc(Size);
   if (!strcmp(Action, "calloc"))
     return calloc((Size + 3) / 4, 4);
   if (!strcmp(Action, "realloc"))
     return realloc(nullptr, Size);
   if (!strcmp(Action, "realloc-after-malloc")) {
     void *P = malloc(100);
     if (void *Ret = realloc(P, Size))
       return Ret;
     free(P);
     return nullptr;
   }
   if (!strcmp(Action, "new"))
     return ::operator new(Size);
   if (!strcmp(Action, "new-nothrow"))
     return ::operator new(Size, std::nothrow);
+  if (!strcmp(Action, "strndup"))
+  {
+    static char pstr[MaxAllocationSize+1] = {'a'};
+    for (size_t i=0; i<MaxAllocationSize+1; i++)
+      pstr[i] = 'a';
+    if (Size == MaxAllocationSize)
+      pstr[MaxAllocationSize-1] = '\0';
+    return strndup(pstr, Size);
+  }
   assert(0);
 }
 
 static void deallocate(const char *Action, void *Ptr) {
   if (!strcmp(Action, "malloc") || !strcmp(Action, "calloc") ||
-      !strcmp(Action, "realloc") || !strcmp(Action, "realloc-after-malloc"))
+      !strcmp(Action, "realloc") || !strcmp(Action, "realloc-after-malloc") || !strcmp(Action, "strndup"))
     return free(Ptr);
   if (!strcmp(Action, "new"))
     return ::operator delete(Ptr);
   if (!strcmp(Action, "new-nothrow"))
     return ::operator delete(Ptr, std::nothrow);
   assert(0);
 }
 
 int main(int Argc, char **Argv) {
   assert(Argc == 2);
   const char *Action = Argv[1];
   fprintf(stderr, "%s:\n", Action);
 
-  constexpr size_t MaxAllocationSize = size_t{2} << 20;
-
   // Should succeed when max_allocation_size_mb is set.
   void *volatile P = allocate(Action, MaxAllocationSize);
   assert(P);
   deallocate(Action, P);
 
   // Should fail when max_allocation_size_mb is set.
   P = allocate(Action, MaxAllocationSize + 1);
   // The NULL pointer is printed differently on different systems, while (long)0

 // CHECK-mrCRASH: realloc-after-malloc:
 // CHECK-mrCRASH: {{SUMMARY: .*Sanitizer: allocation-size-too-big}}
 // CHECK-nCRASH: new:
 // CHECK-nCRASH: {{SUMMARY: .*Sanitizer: allocation-size-too-big}}
 // CHECK-nCRASH-OOM: new:
 // CHECK-nCRASH-OOM: {{SUMMARY: .*Sanitizer: out-of-memory}}
 // CHECK-nnCRASH: new-nothrow:
 // CHECK-nnCRASH: {{SUMMARY: .*Sanitizer: allocation-size-too-big}}
+// CHECK-sCRASH: strndup:
+// CHECK-sCRASH: {{SUMMARY: .*Sanitizer: allocation-size-too-big}}
 
-// CHECK-NULL: {{malloc|calloc|calloc-overflow|realloc|realloc-after-malloc|new-nothrow}}
+// CHECK-NULL: {{malloc|calloc|calloc-overflow|realloc|realloc-after-malloc|new-nothrow|strndup}}
 // CHECK-NULL: errno: 12, P: 0
 //
 // CHECK-NOTNULL-NOT: P: 0