android: cleanup: Rename shared memory functions

The existing function naming and documentation is riddled with
historical cruft. Hopefully it gets better after the changes proposed
here:
* Remove the word "ashmem" from function names that are not necessarily
  backed by /dev/ashmem
* Change function names to CamelCase to match Chromium C++ style
* Inline tiny functions that are used only once
* Add high level docs to functions declared in
  base/android/linker/ashmem.h

Bypass-Check-License: AOSP copyright+license for ashmem.h
Bug: None
Change-Id: I41dcab9406142119b2943234bf4e0cf64d49d484
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/7170448
Commit-Queue: Egor Pasko <[email protected]>
Reviewed-by: Joe Mason <[email protected]>
Cr-Commit-Position: refs/heads/main@{#1550464}
NOKEYCHECK=True
GitOrigin-RevId: 87f99867450bddb99725955ddb722b64d305ed59

Author: pasko

android/linker/ashmem.cc

@@ -53,21 +53,21 @@ namespace {
  */
 
 /* Callback used with __system_property_read_callback. */
-void prop_read_int(void* cookie,
-                   const char* name,
-                   const char* value,
-                   uint32_t serial) {
+void ReadIntProperty(void* cookie,
+                     const char* name,
+                     const char* value,
+                     uint32_t serial) {
   *reinterpret_cast<int*>(cookie) = atoi(value);
   (void)name;
   (void)serial;
 }
 
-int system_property_get_int(const char* name) {
+int SystemPropertyGetInt(const char* name) {
   int result = 0;
   if (__builtin_available(android 26, *)) {
     const prop_info* info = __system_property_find(name);
     if (info) {
-      __system_property_read_callback(info, &prop_read_int, &result);
+      __system_property_read_callback(info, &ReadIntProperty, &result);
     }
   } else {
     char value[PROP_VALUE_MAX] = {};
@@ -78,10 +78,10 @@ int system_property_get_int(const char* name) {
   return result;
 }
 
-int vendor_api_level() {
+int VendorApiLevel() {
   static int v_api_level = -1;
   if (v_api_level < 0) {
-    v_api_level = system_property_get_int("ro.vendor.api_level");
+    v_api_level = SystemPropertyGetInt("ro.vendor.api_level");
   }
   return v_api_level;
 }
@@ -96,7 +96,7 @@ AshmemStatus s_ashmem_status = ASHMEM_STATUS_INIT;
 dev_t s_ashmem_dev;
 
 /* Return the dev_t of a given file path, or 0 if not available, */
-dev_t ashmem_find_dev(const char* path) {
+dev_t FindAshmemDevice(const char* path) {
   struct stat st;
   dev_t result = 0;
   if (stat(path, &st) == 0 && S_ISCHR(st.st_mode)) {
@@ -105,48 +105,30 @@ dev_t ashmem_find_dev(const char* path) {
   return result;
 }
 
-AshmemStatus ashmem_get_status() {
+AshmemStatus GetAshmemSupportStatus() {
   /* NOTE: No need to make this thread-safe, assuming that
    * all threads will find the same value. */
   if (s_ashmem_status != ASHMEM_STATUS_INIT) {
     return s_ashmem_status;
   }
 
-  s_ashmem_dev = ashmem_find_dev(ASHMEM_DEVICE);
+  s_ashmem_dev = FindAshmemDevice(ASHMEM_DEVICE);
   s_ashmem_status = (s_ashmem_dev == 0) ? ASHMEM_STATUS_NOT_SUPPORTED
                                         : ASHMEM_STATUS_SUPPORTED;
   return s_ashmem_status;
 }
 
 /* Returns true iff the ashmem device ioctl should be used for a given fd.
  * NOTE: Try not to use fstat() when possible to avoid performance issues. */
-bool is_ashmem_fd(int fd) {
-  if (ashmem_get_status() == ASHMEM_STATUS_SUPPORTED) {
+bool IsAshmemFd(int fd) {
+  if (GetAshmemSupportStatus() == ASHMEM_STATUS_SUPPORTED) {
     struct stat st;
     return (fstat(fd, &st) == 0 && S_ISCHR(st.st_mode) && st.st_dev != 0 &&
             st.st_dev == s_ashmem_dev);
   }
   return false;
 }
 
-int ashmem_dev_get_prot_region(int fd) {
-  return ioctl(fd, ASHMEM_GET_PROT_MASK);
-}
-
-int ashmem_dev_pin_region(int fd, size_t offset, size_t len) {
-  struct ashmem_pin pin = {static_cast<__u32>(offset), static_cast<__u32>(len)};
-  return ioctl(fd, ASHMEM_PIN, &pin);
-}
-
-int ashmem_dev_unpin_region(int fd, size_t offset, size_t len) {
-  struct ashmem_pin pin = {static_cast<__u32>(offset), static_cast<__u32>(len)};
-  return ioctl(fd, ASHMEM_UNPIN, &pin);
-}
-
-size_t ashmem_dev_get_size_region(int fd) {
-  return ioctl(fd, ASHMEM_GET_SIZE, NULL);
-}
-
 // Starting with API level 26, the following functions from
 // libandroid.so should be used to create shared memory regions,
 // unless the device's vendor.api_level is 202604 (Android 17)
@@ -167,7 +149,7 @@ struct ASharedMemoryFuncs {
 ASharedMemoryFuncs s_ashmem_funcs = {};
 pthread_once_t s_ashmem_funcs_once = PTHREAD_ONCE_INIT;
 
-int memfd_create_region(const char* name, size_t size) {
+int MemfdCreateRegion(const char* name, size_t size) {
   int fd = syscall(__NR_memfd_create, name, MFD_CLOEXEC | MFD_ALLOW_SEALING);
   if (fd < 0) {
     LOG_E("memfd_create(%s, %zd) failed: %m", name, size);
@@ -226,18 +208,18 @@ int memfd_set_prot_region(int fd, int prot) {
   return 0;
 }
 
-int memfd_get_prot_region(int fd) {
+int MemfdGetProtRegion(int fd) {
   int prot = PROT_READ;
   int seals = fcntl(fd, F_GET_SEALS);
   if (seals == -1) {
-    LOG_E("memfd_get_prot_region(%d): F_GET_SEALS failed: %m", fd);
+    LOG_E("MemfdGetProtRegion(%d): F_GET_SEALS failed: %m", fd);
   } else if (!(seals & (F_SEAL_FUTURE_WRITE | F_SEAL_WRITE))) {
     prot |= PROT_WRITE;
   }
   return prot;
 }
 
-void ashmem_init_funcs() {
+void InitAshmemFuncs() {
   ASharedMemoryFuncs* funcs = &s_ashmem_funcs;
   /*
    * When a device conforms to the VSR for API level 202604 (Android 17),
@@ -249,8 +231,8 @@ void ashmem_init_funcs() {
    * the existing sepolicy for appdomain_tmpfs files, just allocate memfds
    * directly if the device conforms to the VSR for API level 202604.
    */
-  if (vendor_api_level() >= 202604) {
-    funcs->create = &memfd_create_region;
+  if (VendorApiLevel() >= 202604) {
+    funcs->create = &MemfdCreateRegion;
     funcs->setProt = &memfd_set_prot_region;
   } else {
     /* Leaked intentionally! */
@@ -262,12 +244,12 @@ void ashmem_init_funcs() {
   }
 }
 
-const ASharedMemoryFuncs* ashmem_get_funcs() {
-  pthread_once(&s_ashmem_funcs_once, &ashmem_init_funcs);
+const ASharedMemoryFuncs* GetAshmemFuncs() {
+  pthread_once(&s_ashmem_funcs_once, &InitAshmemFuncs);
   return &s_ashmem_funcs;
 }
 
-bool is_memfd_fd(int fd) {
+bool IsMemfdFd(int fd) {
   if (fcntl(fd, F_GET_SEALS, 0) == -1) {
     return false;
   }
@@ -276,57 +258,47 @@ bool is_memfd_fd(int fd) {
 
 }  // namespace
 
-int ashmem_create_region(const char* name, size_t size) {
-  return ashmem_get_funcs()->create(name, size);
+int SharedMemoryRegionCreate(const char* name, size_t size) {
+  return GetAshmemFuncs()->create(name, size);
 }
 
-int ashmem_set_prot_region(int fd, int prot) {
-  return ashmem_get_funcs()->setProt(fd, prot);
+int SharedMemoryRegionSetProtectionFlags(int fd, int prot) {
+  return GetAshmemFuncs()->setProt(fd, prot);
 }
 
-int ashmem_get_prot_region(int fd) {
-  if (is_memfd_fd(fd)) {
-    return memfd_get_prot_region(fd);
+int SharedMemoryRegionGetProtectionFlags(int fd) {
+  if (IsMemfdFd(fd)) {
+    return MemfdGetProtRegion(fd);
   }
 
-  if (is_ashmem_fd(fd)) {
-    return ashmem_dev_get_prot_region(fd);
+  if (IsAshmemFd(fd)) {
+    return ioctl(fd, ASHMEM_GET_PROT_MASK);
   }
 
   return -1;
 }
 
-int ashmem_pin_region(int fd, size_t offset, size_t len) {
-  if (is_ashmem_fd(fd)) {
-    return ashmem_dev_pin_region(fd, offset, len);
+int AshmemPinRegion(int fd, size_t offset, size_t len) {
+  if (IsAshmemFd(fd)) {
+    struct ashmem_pin pin = {static_cast<__u32>(offset),
+                             static_cast<__u32>(len)};
+    return ioctl(fd, ASHMEM_PIN, &pin);
   }
   return ASHMEM_NOT_PURGED;
 }
 
-int ashmem_unpin_region(int fd, size_t offset, size_t len) {
-  if (is_ashmem_fd(fd)) {
-    return ashmem_dev_unpin_region(fd, offset, len);
+int AshmemUnpinRegion(int fd, size_t offset, size_t len) {
+  if (IsAshmemFd(fd)) {
+    struct ashmem_pin pin = {static_cast<__u32>(offset),
+                             static_cast<__u32>(len)};
+    return ioctl(fd, ASHMEM_UNPIN, &pin);
   }
   /* NOTE: It is not possible to use madvise() here because it requires a
    * memory address. This could be done in the caller though, instead of
    * this function. */
   return 0;
 }
 
-int ashmem_get_size_region(int fd) {
-  if (is_ashmem_fd(fd)) {
-    return ashmem_dev_get_size_region(fd);
-  }
-
-  struct stat sb;
-  if (fstat(fd, &sb) == -1) {
-    LOG_E("fstat(%d) failed: %m", fd);
-    return -1;
-  }
-
-  return sb.st_size;
-}
-
-int ashmem_device_is_supported() {
-  return ashmem_get_status() == ASHMEM_STATUS_SUPPORTED;
+int AshmemDeviceIsSupported() {
+  return GetAshmemSupportStatus() == ASHMEM_STATUS_SUPPORTED;
 }

android/linker/ashmem.h

@@ -21,21 +21,48 @@
 
 #include <cstddef>
 
-/* Returns true if the ashmem device is supported on this device.
- * Note that even if the device is not supported,
- * ashmem_{create,set_prot,get_prot,get_size}_region() will still work
- * because they will use the ASharedMemory functions from libandroid.so
- * instead. But ashmem_{pin,unpin}_region() will be no-ops. Starting with API
- * level 26, memfd regions are used under the scenes, also working as no-op
- * for pin/unpin.
- */
-int ashmem_device_is_supported();
-
-int ashmem_create_region(const char *name, size_t size);
-int ashmem_set_prot_region(int fd, int prot);
-int ashmem_get_prot_region(int fd);
-int ashmem_pin_region(int fd, size_t offset, size_t len);
-int ashmem_unpin_region(int fd, size_t offset, size_t len);
-int ashmem_get_size_region(int fd);
+// Management of shared memory regions changed across OS releases. These minimal
+// low level wrappers abstract away those release-specific differences.
+
+// On new OS releases returns false.
+//
+// On old systems returns true when the "/dev/ashmem" device is present on the
+// system and looks 'functional'.
+//
+// Without /dev/ashmem the functions below will continue working, but may
+// use different mechanisms and system library calls under the scenes.
+//
+// The functions can be disabled system-wide without removing /dev/ashmem. This
+// should be rare, and the rest of the functions declared below will behave just
+// like /dev/ashmem does not exist.
+int AshmemDeviceIsSupported();
+
+// Implements ASharedMemory_create(), as described in NDK docs (API level 26).
+int SharedMemoryRegionCreate(const char* name, size_t size);
+
+// Implements ASharedMemory_setProt(), as described in NDK docs (API level 26).
+int SharedMemoryRegionSetProtectionFlags(int fd, int prot);
+
+// Returns the memory protection flags for the region (PROT_READ, PROT_WRITE or
+// both).
+int SharedMemoryRegionGetProtectionFlags(int fd);
+
+// Pins the region to memory on old systems.
+//
+// Behaves as no-op when the region is not served by the ashmem device
+// (irrelevant FDs).
+//
+// Note: Even if AshmemDeviceIsSupported() is true, pinning may still be
+// disabled.
+// Note: This functionality was never officially provided by Android NDK, and
+// the underlying mechanisms are being removed.
+int AshmemPinRegion(int fd, size_t offset, size_t len);
+
+// Unpins the region from memory on old systems, allowing the OS to free it
+// without asking the userspace.
+//
+// Just like the AshmemPinRegion() above, behaves as no-op when the OS support
+// is removed. Also it is a no-op for irrelevant FDs.
+int AshmemUnpinRegion(int fd, size_t offset, size_t len);
 
 #endif  // BASE_ANDROID_LINKER_ASHMEM_H_

android/linker/linker_jni.cc

@@ -489,13 +489,13 @@ bool NativeLibInfo::CreateSharedRelroFd() {
   }
 
   // Create a writable shared memory region.
-  int shared_mem_fd = ashmem_create_region("cr_relro", relro_size_);
+  int shared_mem_fd = SharedMemoryRegionCreate("cr_relro", relro_size_);
   if (shared_mem_fd == -1) {
     LOG_ERROR("Cannot create the shared memory file");
     return false;
   }
   int rw_flags = PROT_READ | PROT_WRITE;
-  ashmem_set_prot_region(shared_mem_fd, rw_flags);
+  SharedMemoryRegionSetProtectionFlags(shared_mem_fd, rw_flags);
 
   // Map the region as writable.
   void* relro_copy_addr =
@@ -519,7 +519,7 @@ bool NativeLibInfo::CreateSharedRelroFd() {
   // writable memory mappings, since they are not directly affected by the
   // change of region's protection flags.
   munmap(relro_copy_addr, relro_size_);
-  if (ashmem_set_prot_region(shared_mem_fd, PROT_READ) == -1) {
+  if (SharedMemoryRegionSetProtectionFlags(shared_mem_fd, PROT_READ) == -1) {
     LOG_ERROR("Failed to set the RELRO FD as read-only.");
     close(shared_mem_fd);
     return false;

memory/discardable_shared_memory.cc

@@ -134,7 +134,7 @@ size_t AlignToPageSize(size_t size) {
 
 #if BUILDFLAG(IS_ANDROID)
 bool UseAshmemUnpinningForDiscardableMemory() {
-  if (!ashmem_device_is_supported()) {
+  if (!AshmemDeviceIsSupported()) {
     return false;
   }
 
@@ -544,7 +544,7 @@ DiscardableSharedMemory::LockResult DiscardableSharedMemory::LockPages(
   if (region.IsValid()) {
     if (UseAshmemUnpinningForDiscardableMemory()) {
       int pin_result =
-          ashmem_pin_region(region.GetPlatformHandle(), offset, length);
+          AshmemPinRegion(region.GetPlatformHandle(), offset, length);
       if (pin_result == ASHMEM_WAS_PURGED) {
         return PURGED;
       }
@@ -566,7 +566,7 @@ void DiscardableSharedMemory::UnlockPages(
   if (region.IsValid()) {
     if (UseAshmemUnpinningForDiscardableMemory()) {
       int unpin_result =
-          ashmem_unpin_region(region.GetPlatformHandle(), offset, length);
+          AshmemUnpinRegion(region.GetPlatformHandle(), offset, length);
       DCHECK_EQ(0, unpin_result);
     }
   }