text: /*
   * Copyright (C) 2016 The Android Open Source Project
   *
   * 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 "core_jni_helpers.h"
  #include <cutils/ashmem.h>
  #include <linux/ashmem.h>
  #include <sys/mman.h>
  
  namespace android {
  
  static jint android_util_MemoryIntArray_create(JNIEnv* env, jobject clazz, jstring name,
          jint size)
  {
      if (name == NULL) {
          jniThrowException(env, "java/io/IOException", "bad name");
          return -1;
      }
  
      if (size <= 0) {
          jniThrowException(env, "java/io/IOException", "bad size");
          return -1;
      }
  
      const char* nameStr = env->GetStringUTFChars(name, NULL);
      const int ashmemSize = sizeof(std::atomic_int) * size;
      int fd = ashmem_create_region(nameStr, ashmemSize);
      env->ReleaseStringUTFChars(name, nameStr);
  
      if (fd < 0) {
          jniThrowException(env, "java/io/IOException", "ashmem creation failed");
          return -1;
      }
  
      int setProtResult = ashmem_set_prot_region(fd, PROT_READ | PROT_WRITE);
      if (setProtResult < 0) {
          jniThrowException(env, "java/io/IOException", "cannot set ashmem prot mode");
          return -1;
      }
  
      return fd;
  }
  
  static jlong android_util_MemoryIntArray_open(JNIEnv* env, jobject clazz, jint fd,
      jboolean owner)
  {
      if (fd < 0) {
          jniThrowException(env, "java/io/IOException", "bad file descriptor");
          return -1;
      }
  
      if (!ashmem_valid(fd)) {
          jniThrowIOException(env, errno);
          return -1;
      }
  
      int ashmemSize = ashmem_get_size_region(fd);
      if (ashmemSize <= 0) {
          jniThrowException(env, "java/io/IOException", "bad ashmem size");
          return -1;
      }
  
      // IMPORTANT: Ashmem allows the caller to change its size until
      // it is memory mapped for the first time which lazily creates
      // the underlying VFS file. So the size we get above may not
      // reflect the size of the underlying shared memory region. Therefore,
      // we first memory map to set the size in stone an verify if
      // the underlying ashmem region has the same size as the one we
      // memory mapped. This is critical as we use the underlying
      // ashmem size for boundary checks and memory unmapping.
      int protMode = owner ? (PROT_READ | PROT_WRITE) : PROT_READ;
      void* ashmemAddr = mmap(NULL, ashmemSize, protMode, MAP_SHARED, fd, 0);
      if (ashmemAddr == MAP_FAILED) {
          jniThrowException(env, "java/io/IOException", "cannot mmap ashmem");
          return -1;
      }
  
      // Check if the mapped size is the same as the ashmem region.
      int mmapedSize = ashmem_get_size_region(fd);
      if (mmapedSize != ashmemSize) {
          munmap(reinterpret_cast<void *>(ashmemAddr), ashmemSize);
          jniThrowException(env, "java/io/IOException", "bad file descriptor");
          return -1;
      }
  
      if (owner) {
          int size = ashmemSize / sizeof(std::atomic_int);
          new (ashmemAddr) std::atomic_int[size];
      }
  
      if (owner) {
          int setProtResult = ashmem_set_prot_region(fd, PROT_READ);
          if (setProtResult < 0) {
              jniThrowException(env, "java/io/IOException", "cannot set ashmem prot mode");
              return -1;
          }
      }
  
      return reinterpret_cast<jlong>(ashmemAddr);
  }
  
  static void android_util_MemoryIntArray_close(JNIEnv* env, jobject clazz, jint fd,
      jlong ashmemAddr, jboolean owner)
  {
      if (fd < 0) {
          jniThrowException(env, "java/io/IOException", "bad file descriptor");
          return;
      }
  
      if (!ashmem_valid(fd)) {
          jniThrowIOException(env, errno);
          return;
      }
  
      int ashmemSize = ashmem_get_size_region(fd);
      if (ashmemSize <= 0) {
          jniThrowException(env, "java/io/IOException", "bad ashmem size");
          return;
      }
  
      int unmapResult = munmap(reinterpret_cast<void *>(ashmemAddr), ashmemSize);
      if (unmapResult < 0) {
          jniThrowException(env, "java/io/IOException", "munmap failed");
          return;
      }
  
      // We don't deallocate the atomic ints we created with placement new in the ashmem
      // region as the kernel we reclaim all pages when the ashmem region is destroyed.
      if (owner && (ashmem_unpin_region(fd, 0, 0) != ASHMEM_IS_UNPINNED)) {
          jniThrowException(env, "java/io/IOException", "ashmem unpinning failed");
          return;
      }
  
      close(fd);
  }
  
  static jint android_util_MemoryIntArray_get(JNIEnv* env, jobject clazz,
          jint fd, jlong address, jint index)
  {
      if (fd < 0) {
          jniThrowException(env, "java/io/IOException", "bad file descriptor");
          return -1;
      }
  
      if (!ashmem_valid(fd)) {
          jniThrowIOException(env, errno);
          return -1;
      }
  
      if (ashmem_pin_region(fd, 0, 0) == ASHMEM_WAS_PURGED) {
          jniThrowException(env, "java/io/IOException", "ashmem region was purged");
          return -1;
      }
  
      std::atomic_int* value = reinterpret_cast<std::atomic_int*>(address) + index;
      return value->load(std::memory_order_relaxed);
  }
  
  static void android_util_MemoryIntArray_set(JNIEnv* env, jobject clazz,
          jint fd, jlong address, jint index, jint newValue)
  {
      if (fd < 0) {
          jniThrowException(env, "java/io/IOException", "bad file descriptor");
          return;
      }
  
      if (!ashmem_valid(fd)) {
          jniThrowIOException(env, errno);
          return;
      }
  
      if (ashmem_pin_region(fd, 0, 0) == ASHMEM_WAS_PURGED) {
          jniThrowException(env, "java/io/IOException", "ashmem region was purged");
          return;
      }
  
      std::atomic_int* value = reinterpret_cast<std::atomic_int*>(address) + index;
      value->store(newValue, std::memory_order_relaxed);
  }
  
  static jint android_util_MemoryIntArray_size(JNIEnv* env, jobject clazz, jint fd) {
      if (fd < 0) {
          jniThrowException(env, "java/io/IOException", "bad file descriptor");
          return -1;
      }
  
      if (!ashmem_valid(fd)) {
          jniThrowIOException(env, errno);
          return -1;
      }
  
      int ashmemSize = ashmem_get_size_region(fd);
      if (ashmemSize < 0) {
          jniThrowIOException(env, errno);
          return -1;
      }
      return ashmemSize / sizeof(std::atomic_int);
  }
  
  static const JNINativeMethod methods[] = {
      {"nativeCreate",  "(Ljava/lang/String;I)I", (void*)android_util_MemoryIntArray_create},
      {"nativeOpen",  "(IZ)J", (void*)android_util_MemoryIntArray_open},
      {"nativeClose", "(IJZ)V", (void*)android_util_MemoryIntArray_close},
      {"nativeGet",  "(IJI)I", (void*)android_util_MemoryIntArray_get},
      {"nativeSet", "(IJII)V", (void*) android_util_MemoryIntArray_set},
      {"nativeSize", "(I)I", (void*) android_util_MemoryIntArray_size},
  };
  
  int register_android_util_MemoryIntArray(JNIEnv* env)
  {
      return RegisterMethodsOrDie(env, "android/util/MemoryIntArray", methods, NELEM(methods));
  }
  
  }
  