Teach MemoryMapping to size Android ashmem fds

Summary:
### THIS DIFF
Teach `folly::MemoryMapping` to size Android ashmem-backed file descriptors transparently by probing `ASharedMemory_getSize(fd)` before falling back to `fstat()`, and add coverage for that path.

### PLAN
1. Add legacy regular-file coverage.
2. Teach `folly::MemoryMapping` to size Android shared-memory fds transparently.
3. Migrate Codec Avatar back to `folly::MemoryMapping` and delete `SharedMemoryMapping`.

### CONTEXT
Codec Avatar currently needs a custom Android-only mapping path because ashmem-backed render asset fds report an unusable size through the existing Folly path. This diff fixes that gap in Folly without adding a new caller-visible API and preserves the existing regular-file behavior when the ashmem probe does not apply.

Differential Revision: D99928672

fbshipit-source-id: a86432e7c380983a053bdd1430bde2686960c651

Author: scramsby

folly/system/MemoryMapping.cpp

@@ -33,6 +33,11 @@
 #include <folly/portability/SysSyscall.h>
 #include <folly/portability/Unistd.h>
 
+#ifdef __ANDROID__
+#include <dlfcn.h>
+#include <sys/ioctl.h>
+#endif
+
 static constexpr ssize_t kDefaultMlockChunkSize = !folly::kMscVer
     // Linux implementations of unmap/mlock/munlock take a kernel
     // semaphore and block other threads from doing other memory
@@ -60,6 +65,20 @@ enum mmap_flags : int {
 #endif
 };
 
+#ifdef __ANDROID__
+constexpr unsigned long kAshmemGetSizeIoctl = 0x00007704; // _IO(0x77, 4)
+
+off64_t getAndroidSharedMemorySize(int fd) {
+  using GetSizeFn = size_t (*)(int);
+  static const auto getSize =
+      reinterpret_cast<GetSizeFn>(dlsym(RTLD_DEFAULT, "ASharedMemory_getSize"));
+  const auto size = getSize != nullptr
+      ? getSize(fd)
+      : static_cast<size_t>(ioctl(fd, kAshmemGetSizeIoctl, 0));
+  return size > 0 ? static_cast<off64_t>(size) : -1;
+}
+#endif
+
 } // namespace
 
 MemoryMapping::MemoryMapping(MemoryMapping&& other) noexcept {
@@ -102,6 +121,28 @@ void getDeviceOptions(dev_t device, off64_t& pageSize, bool& autoExtend) {
   }
 }
 
+off64_t getFileSize(File const& file, off64_t& pageSize, bool& autoExtend) {
+#ifdef _WIN32
+  // stat that support files larger then 4Gb
+  struct _stat64 st;
+  CHECK_ERR(_fstat64(file.fd(), &st));
+#else
+  struct stat st{};
+  CHECK_ERR(fstat(file.fd(), &st));
+#endif
+
+  if (pageSize == 0) {
+    getDeviceOptions(st.st_dev, pageSize, autoExtend);
+  }
+#ifdef __ANDROID__
+  const auto fileSize = getAndroidSharedMemorySize(file.fd());
+  if (fileSize >= 0) {
+    return fileSize;
+  }
+#endif
+  return st.st_size;
+}
+
 } // namespace
 
 void MemoryMapping::init(off64_t offset, off64_t length) {
@@ -111,28 +152,14 @@ void MemoryMapping::init(off64_t offset, off64_t length) {
 
   off64_t& pageSize = options_.pageSize;
 
-#ifdef _WIN32
-  // stat that support files larger then 4Gb
-  struct _stat64 st;
-#else
-  struct stat st;
-#endif
-
   // On Linux, hugetlbfs file systems don't require ftruncate() to grow the
   // file, and (on kernels before 2.6.24) don't even allow it. Also, the file
   // size is always a multiple of the page size.
   bool autoExtend = false;
+  off64_t fileSize = 0;
 
   if (!anon) {
-// Stat the file
-#ifdef _WIN32
-    CHECK_ERR(_fstat64(file_.fd(), &st));
-#else
-    CHECK_ERR(fstat(file_.fd(), &st));
-#endif
-    if (pageSize == 0) {
-      getDeviceOptions(st.st_dev, pageSize, autoExtend);
-    }
+    fileSize = getFileSize(file_, pageSize, autoExtend);
   } else {
     DCHECK(!file_);
     DCHECK_EQ(offset, 0);
@@ -160,7 +187,7 @@ void MemoryMapping::init(off64_t offset, off64_t length) {
     mapLength_ = (mapLength_ + pageSize - 1) / pageSize * pageSize;
   }
 
-  off64_t remaining = anon ? length : st.st_size - offset;
+  off64_t remaining = anon ? length : fileSize - offset;
 
   if (mapLength_ == -1) {
     length = mapLength_ = remaining;
@@ -313,7 +340,7 @@ bool MemoryMapping::mlock(LockMode mode, LockFlags flags) {
         // If no flags are set, mlock2() behaves exactly the same as
         // mlock(). Prefer the portable variant.
         return !flags.lockOnFault
-            ? ::mlock(addr, len)
+            ? ::mlock(addr, len) // NOLINT(facebook-hte-BadCall-mlock)
             : mlock2wrapper(addr, len, flags);
       },
       mapStart_,
@@ -413,7 +440,7 @@ void MemoryMapping::advise(int advice, size_t offset, size_t length) const {
   PLOG_IF(WARNING, ::madvise(mapStart, length, advice)) << "madvise";
 }
 
-MemoryMapping& MemoryMapping::operator=(MemoryMapping&& other) {
+MemoryMapping& MemoryMapping::operator=(MemoryMapping&& other) noexcept {
   swap(other);
   return *this;
 }

folly/system/MemoryMapping.h

@@ -176,7 +176,7 @@ class MemoryMapping {
   ~MemoryMapping();
 
   MemoryMapping& operator=(const MemoryMapping&) = delete;
-  MemoryMapping& operator=(MemoryMapping&&);
+  MemoryMapping& operator=(MemoryMapping&&) noexcept;
 
   void swap(MemoryMapping& other) noexcept;
 

folly/system/test/BUCK

@@ -1,8 +1,46 @@
 load("@fbsource//tools/build_defs:fb_xplat_cxx_test.bzl", "fb_xplat_cxx_test")
 load("@fbsource//tools/build_defs:platform_defs.bzl", "ANDROID", "CXX", "FBCODE")
 load("@fbsource//tools/build_defs/dirsync:fb_dirsync_cpp_unittest.bzl", "fb_dirsync_cpp_unittest")
+load("@fbsource//tools/target_determinator/macros:ci.bzl", "ci")
 load("@fbsource//xplat/pfh/triage_InfrastructureSupermoduleOptou:DEFS.bzl", "triage_InfrastructureSupermoduleOptou")
 
+# Android API level gate for ashmem tests.  ASharedMemory_create() requires
+# API 26+.  FOLLY_TEST_HAS_ASHMEM is passed as a compiler flag so the C++
+# source does not duplicate the threshold.
+_ASHMEM_FLAG = ["-DFOLLY_TEST_HAS_ASHMEM=1"]
+
+_ASHMEM_TOOLCHAIN = ["fbsource//third-party/toolchains:android"]
+
+_ASHMEM_COMPILER_FLAGS = select({
+    "DEFAULT": [],
+    "ovr_config//os/version/android:api-level-26": _ASHMEM_FLAG,
+    "ovr_config//os/version/android:api-level-27": _ASHMEM_FLAG,
+    "ovr_config//os/version/android:api-level-28": _ASHMEM_FLAG,
+    "ovr_config//os/version/android:api-level-29": _ASHMEM_FLAG,
+    "ovr_config//os/version/android:api-level-30": _ASHMEM_FLAG,
+    "ovr_config//os/version/android:api-level-31": _ASHMEM_FLAG,
+    "ovr_config//os/version/android:api-level-32": _ASHMEM_FLAG,
+    "ovr_config//os/version/android:api-level-33": _ASHMEM_FLAG,
+    "ovr_config//os/version/android:api-level-34": _ASHMEM_FLAG,
+    "ovr_config//os/version/android:api-level-35": _ASHMEM_FLAG,
+    "ovr_config//os/version/android:api-level-36": _ASHMEM_FLAG,
+})
+
+_ASHMEM_DEPS = select({
+    "DEFAULT": [],
+    "ovr_config//os/version/android:api-level-26": _ASHMEM_TOOLCHAIN,
+    "ovr_config//os/version/android:api-level-27": _ASHMEM_TOOLCHAIN,
+    "ovr_config//os/version/android:api-level-28": _ASHMEM_TOOLCHAIN,
+    "ovr_config//os/version/android:api-level-29": _ASHMEM_TOOLCHAIN,
+    "ovr_config//os/version/android:api-level-30": _ASHMEM_TOOLCHAIN,
+    "ovr_config//os/version/android:api-level-31": _ASHMEM_TOOLCHAIN,
+    "ovr_config//os/version/android:api-level-32": _ASHMEM_TOOLCHAIN,
+    "ovr_config//os/version/android:api-level-33": _ASHMEM_TOOLCHAIN,
+    "ovr_config//os/version/android:api-level-34": _ASHMEM_TOOLCHAIN,
+    "ovr_config//os/version/android:api-level-35": _ASHMEM_TOOLCHAIN,
+    "ovr_config//os/version/android:api-level-36": _ASHMEM_TOOLCHAIN,
+})
+
 oncall("fbcode_entropy_wardens_folly")
 
 fb_dirsync_cpp_unittest(
@@ -61,20 +99,26 @@ fb_dirsync_cpp_unittest(
 fb_dirsync_cpp_unittest(
     name = "memory_mapping_test",
     srcs = ["MemoryMappingTest.cpp"],
+    compiler_flags = _ASHMEM_COMPILER_FLAGS,
     feature = triage_InfrastructureSupermoduleOptou,
     platforms = (ANDROID, CXX, FBCODE),
     use_instrumentation_test = True,
     # TODO(T263893609): Drop this explicit override once folly_xplat_cxx_test
     # forwards Android test attrs correctly for xplat/folly tests.
     xplat_impl = fb_xplat_cxx_test,
+    # Run with arvr Android API 34 mode so the ashmem test (gated on
+    # __ANDROID_API__ >= _ASHMEM_MIN_API) compiles and executes in CI.
+    xplat_labels = ci.labels(
+        ci.linux(ci.mode("fbsource//arvr/mode/android/apk/linux/dev")),
+    ),
     deps = [
         "fbsource//third-party/glog:glog",
         "//folly:file_util",
         "//folly:random",
         "//folly/portability:gtest",
         "//folly/portability:sys_mman",
         "//folly/system:memory_mapping",
-    ],
+    ] + _ASHMEM_DEPS,
 )
 
 fb_dirsync_cpp_unittest(

folly/system/test/MemoryMappingTest.cpp

@@ -25,6 +25,18 @@
 #include <folly/portability/GTest.h>
 #include <folly/portability/SysMman.h>
 
+// FOLLY_TEST_HAS_ASHMEM is defined by Buck (compiler_flags) when the Android
+// API level is high enough for ASharedMemory_create().  Default to 0 so the
+// test compiles on non-Android and on older Android API levels.
+#ifndef FOLLY_TEST_HAS_ASHMEM
+#define FOLLY_TEST_HAS_ASHMEM 0
+#endif
+
+#if FOLLY_TEST_HAS_ASHMEM
+#include <algorithm>
+#include <android/sharedmem.h>
+#endif
+
 static constexpr double kSomeDouble = 3.14;
 
 namespace folly {
@@ -176,6 +188,25 @@ TEST(MemoryMapping, WritableMappingGrowsRegularFileToRequestedLength) {
   EXPECT_EQ('!', m.data()[7]);
 }
 
+#if FOLLY_TEST_HAS_ASHMEM
+TEST(MemoryMapping, ExplicitLengthUsesAshmemSize) {
+  constexpr size_t kSize = 8;
+  folly::File f(ASharedMemory_create("folly-memory-mapping-test", kSize), true);
+  ASSERT_TRUE(f);
+
+  void* const address =
+      mmap(nullptr, kSize, PROT_READ | PROT_WRITE, MAP_SHARED, f.fd(), 0);
+  ASSERT_NE(MAP_FAILED, address);
+  const StringPiece kData = "ashmem!!";
+  std::copy_n(kData.data(), kData.size(), static_cast<char*>(address));
+  ASSERT_EQ(0, munmap(address, kSize));
+
+  MemoryMapping m(File(f.fd()), 0, 99);
+  EXPECT_EQ(kSize, m.data().size());
+  EXPECT_EQ(kData, m.data().subpiece(0, kSize));
+}
+#endif
+
 TEST(MemoryMapping, ZeroLength) {
   File f = File::temporary();
   MemoryMapping m(File(f.fd()));