/*
|
* 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));
|
}
|
|
}
|
