1 /* 2 * Copyright (C) 2016 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #define LOG_TAG "AshmemAllocator" 18 #include <android-base/logging.h> 19 20 #include "AshmemAllocator.h" 21 22 #include <cutils/ashmem.h> 23 24 namespace android { 25 namespace hidl { 26 namespace allocator { 27 namespace V1_0 { 28 namespace implementation { 29 30 static hidl_memory allocateOne(uint64_t size) { 31 int fd = ashmem_create_region("AshmemAllocator_hidl", size); 32 if (fd < 0) { 33 LOG(WARNING) << "ashmem_create_region(" << size << ") fails with " << fd; 34 return hidl_memory(); 35 } 36 37 native_handle_t* handle = native_handle_create(1, 0); 38 handle->data[0] = fd; 39 LOG(WARNING) << "ashmem_create_region(" << size << ") returning hidl_memory(" << handle 40 << ", " << size << ")"; 41 return hidl_memory("ashmem", handle, size); 42 } 43 44 static void cleanup(hidl_memory&& memory) { 45 if (memory.handle() == nullptr) { 46 return; 47 } 48 49 native_handle_close(const_cast<native_handle_t *>(memory.handle())); 50 native_handle_delete(const_cast<native_handle_t *>(memory.handle())); 51 } 52 53 Return<void> AshmemAllocator::allocate(uint64_t size, allocate_cb _hidl_cb) { 54 hidl_memory memory = allocateOne(size); 55 _hidl_cb(memory.handle() != nullptr /* success */, memory); 56 cleanup(std::move(memory)); 57 58 return Void(); 59 } 60 61 Return<void> AshmemAllocator::batchAllocate(uint64_t size, uint64_t count, batchAllocate_cb _hidl_cb) { 62 // resize fails if count > 2^32 63 if (count > UINT32_MAX) { 64 _hidl_cb(false /* success */, {}); 65 return Void(); 66 } 67 68 hidl_vec<hidl_memory> batch; 69 batch.resize(count); 70 71 uint64_t allocated; 72 for (allocated = 0; allocated < count; allocated++) { 73 batch[allocated] = allocateOne(size); 74 75 if (batch[allocated].handle() == nullptr) { 76 LOG(WARNING) << "batchAllocate(" << size << ", " << count << ") fails @ #" << allocated; 77 break; 78 } 79 } 80 81 // batch[i].handle() != nullptr for i in [0, allocated - 1]. 82 // batch[i].handle() == nullptr for i in [allocated, count - 1]. 83 84 if (allocated < count) { 85 _hidl_cb(false /* success */, {}); 86 } else { 87 _hidl_cb(true /* success */, batch); 88 } 89 90 for (uint64_t i = 0; i < allocated; i++) { 91 cleanup(std::move(batch[i])); 92 } 93 94 return Void(); 95 } 96 97 } // namespace implementation 98 } // namespace V1_0 99 } // namespace allocator 100 } // namespace hidl 101 } // namespace android 102
