android: Support mmap() with large file offsets and API < 21

Chrome (and therefore mini_chromium) has always built with
_FILE_OFFSET_BITS=64, which is intended to enable a 64-bit off_t even
for 32-bit programs. However, support was never present in Android with
NDK traditional headers.

The new NDK unified headers do recognize _FILE_OFFSET_BITS=64 and enable
a 64-bit off_t, along with corresponding functions and system call
wrappers. However, no mmap() wrapper supporting a 64-bit off_t for
32-bit programs was available prior to API 21 (Android 5.0 “Lollipop”),
so when targeting older API levels, NDK headers do not proivde an mmap()
declaration. This avoids silently truncating 64-bit off_t values to 32
bits. NDK r15b did make such an mmap() wrapper available
(https://android.googlesource.com/platform/bionic/+/785b249df024), and
it did silently truncate, but this was removed for r15c
(https://android.googlesource.com/platform/bionic/+/00fedf587917).

How should this work if _FILE_OFFSET_BITS is set to 64 and recent
unified headers are in use?

The strategy employed here is to provide an mmap() declaration in
compat, with a 64-bit off_t. That mmap() will call to Bionic’s mmap64()
wrapper if available (it’s available since Android 5.0 “Lollipop”). If
unavailable, it implements the same logic that mmap64() does directly,
which predominantly involves calling the __mmap2() system call. Bionic
has always provided wrappers for __mmap2().

Additional reading:
https://android.googlesource.com/platform/bionic/+/0bfcbaf4d069/docs/32-bit-abi.md#is-32_bit-1
https://github.com/android-ndk/ndk/issues/442

Bug: crashpad:30
Change-Id: I98c10e2eda773cb6f3d9eb8db9b8bfde43c885e7
Reviewed-on: https://chromium-review.googlesource.com/705674
Reviewed-by: Joshua Peraza <jperaza@chromium.org>

compat/android/sys/mman.cc

@@ -0,0 +1,103 @@
+// Copyright 2017 The Crashpad Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <sys/mman.h>
+
+#include <dlfcn.h>
+#include <errno.h>
+#include <stdint.h>
+#include <unistd.h>
+
+#if defined(__USE_FILE_OFFSET64) && __ANDROID_API__ < 21
+
+// Bionic has provided a wrapper for __mmap2() since the beginning of time. See
+// bionic/libc/SYSCALLS.TXT in any Android version.
+extern "C" void* __mmap2(void* addr,
+                         size_t size,
+                         int prot,
+                         int flags,
+                         int fd,
+                         size_t pgoff);
+
+namespace {
+
+template <typename T>
+T Align(T value, uint8_t alignment) {
+  return (value + alignment - 1) & ~(alignment - 1);
+}
+
+// Adapted from Android 8.0.0 bionic/libc/bionic/mmap.cpp.
+void* LocalMmap64(void* addr,
+                  size_t size,
+                  int prot,
+                  int flags,
+                  int fd,
+                  off64_t offset) {
+  constexpr int kMmap2Shift = 12;
+
+  if (offset < 0 || (offset & ((1UL << kMmap2Shift) - 1)) != 0) {
+    errno = EINVAL;
+    return MAP_FAILED;
+  }
+
+  const size_t rounded = Align(size, getpagesize());
+  if (rounded < size || rounded > PTRDIFF_MAX) {
+    errno = ENOMEM;
+    return MAP_FAILED;
+  }
+
+  const bool is_private_anonymous =
+      (flags & (MAP_PRIVATE | MAP_ANONYMOUS)) == (MAP_PRIVATE | MAP_ANONYMOUS);
+  const bool is_stack_or_grows_down =
+      (flags & (MAP_STACK | MAP_GROWSDOWN)) != 0;
+
+  void* const result =
+      __mmap2(addr, size, prot, flags, fd, offset >> kMmap2Shift);
+
+  static bool kernel_has_MADV_MERGEABLE = true;
+  if (result != MAP_FAILED && kernel_has_MADV_MERGEABLE &&
+      is_private_anonymous && !is_stack_or_grows_down) {
+    const int saved_errno = errno;
+    const int rc = madvise(result, size, MADV_MERGEABLE);
+    if (rc == -1 && errno == EINVAL) {
+      kernel_has_MADV_MERGEABLE = false;
+    }
+    errno = saved_errno;
+  }
+
+  return result;
+}
+
+}  // namespace
+
+extern "C" {
+
+void* mmap(void* addr, size_t size, int prot, int flags, int fd, off_t offset) {
+  // Use the system’s mmap64() wrapper if available. It will be available on
+  // Android 5.0 (“Lollipop”) and later.
+  using Mmap64Type = void* (*)(void*, size_t, int, int, int, off64_t);
+  static const Mmap64Type mmap64 =
+      reinterpret_cast<Mmap64Type>(dlsym(RTLD_DEFAULT, "mmap64"));
+  if (mmap64) {
+    return mmap64(addr, size, prot, flags, fd, offset);
+  }
+
+  // Otherwise, use the local implementation, which should amount to exactly the
+  // same thing.
+  return LocalMmap64(addr, size, prot, flags, fd, offset);
+}
+
+}  // extern "C"
+
+#endif  // defined(__USE_FILE_OFFSET64) && __ANDROID_API__ < 21

compat/android/sys/mman.h

@@ -0,0 +1,43 @@
+// Copyright 2017 The Crashpad Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef CRASHPAD_COMPAT_ANDROID_SYS_MMAN_H_
+#define CRASHPAD_COMPAT_ANDROID_SYS_MMAN_H_
+
+#include_next <sys/mman.h>
+
+#include <android/api-level.h>
+#include <sys/cdefs.h>
+
+// There’s no mmap() wrapper compatible with a 64-bit off_t for 32-bit code
+// until API 21 (Android 5.0/“Lollipop”). A custom mmap() wrapper is provided
+// here. Note that this scenario is only possible with NDK unified headers.
+//
+// https://android.googlesource.com/platform/bionic/+/0bfcbaf4d069e005d6e959d97f8d11c77722b70d/docs/32-bit-abi.md#is-32_bit-1
+
+#if defined(__USE_FILE_OFFSET64) && __ANDROID_API__ < 21
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void* mmap(void* addr, size_t size, int prot, int flags, int fd, off_t offset);
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // defined(__USE_FILE_OFFSET64) && __ANDROID_API__ < 21
+
+#endif  // CRASHPAD_COMPAT_ANDROID_SYS_MMAN_H_

compat/compat.gyp

@@ -26,6 +26,8 @@
         'android/linux/prctl.h',
         'android/linux/ptrace.h',
         'android/sched.h',
+        'android/sys/mman.cc',
+        'android/sys/mman.h',
         'android/sys/syscall.h',
         'android/sys/user.h',
         'linux/signal.h',
@@ -105,6 +107,11 @@
               'linux',
             ],
           },
+          'link_settings': {
+            'libraries': [
+              '-ldl',
+            ],
+          },
         }],
         ['OS=="linux"', {
           'include_dirs': [