1 /*
2 **
3 ** Copyright 2009, The Android Open Source Project
4 **
5 ** Licensed under the Apache License, Version 2.0 (the "License");
6 ** you may not use this file except in compliance with the License.
7 ** You may obtain a copy of the License at
8 **
9 **     http://www.apache.org/licenses/LICENSE-2.0
10 **
11 ** Unless required by applicable law or agreed to in writing, software
12 ** distributed under the License is distributed on an "AS IS" BASIS,
13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 ** See the License for the specific language governing permissions and
15 ** limitations under the License.
16 */
17 
18 #define LOG_TAG "GraphicBufferAllocator"
19 #define ATRACE_TAG ATRACE_TAG_GRAPHICS
20 
21 #include <ui/GraphicBufferAllocator.h>
22 
23 #include <limits.h>
24 #include <stdio.h>
25 
26 #include <grallocusage/GrallocUsageConversion.h>
27 
28 #include <android-base/stringprintf.h>
29 #include <log/log.h>
30 #include <utils/Singleton.h>
31 #include <utils/Trace.h>
32 
33 #include <ui/Gralloc.h>
34 #include <ui/Gralloc2.h>
35 #include <ui/Gralloc3.h>
36 #include <ui/Gralloc4.h>
37 #include <ui/GraphicBufferMapper.h>
38 
39 namespace android {
40 // ---------------------------------------------------------------------------
41 
42 using base::StringAppendF;
43 
44 ANDROID_SINGLETON_STATIC_INSTANCE( GraphicBufferAllocator )
45 
46 Mutex GraphicBufferAllocator::sLock;
47 KeyedVector<buffer_handle_t,
48     GraphicBufferAllocator::alloc_rec_t> GraphicBufferAllocator::sAllocList;
49 
GraphicBufferAllocator()50 GraphicBufferAllocator::GraphicBufferAllocator() : mMapper(GraphicBufferMapper::getInstance()) {
51     mAllocator = std::make_unique<const Gralloc4Allocator>(
52             reinterpret_cast<const Gralloc4Mapper&>(mMapper.getGrallocMapper()));
53     if (mAllocator->isLoaded()) {
54         return;
55     }
56     mAllocator = std::make_unique<const Gralloc3Allocator>(
57             reinterpret_cast<const Gralloc3Mapper&>(mMapper.getGrallocMapper()));
58     if (mAllocator->isLoaded()) {
59         return;
60     }
61     mAllocator = std::make_unique<const Gralloc2Allocator>(
62             reinterpret_cast<const Gralloc2Mapper&>(mMapper.getGrallocMapper()));
63     if (mAllocator->isLoaded()) {
64         return;
65     }
66 
67     LOG_ALWAYS_FATAL("gralloc-allocator is missing");
68 }
69 
~GraphicBufferAllocator()70 GraphicBufferAllocator::~GraphicBufferAllocator() {}
71 
getTotalSize() const72 uint64_t GraphicBufferAllocator::getTotalSize() const {
73     Mutex::Autolock _l(sLock);
74     uint64_t total = 0;
75     for (size_t i = 0; i < sAllocList.size(); ++i) {
76         total += sAllocList.valueAt(i).size;
77     }
78     return total;
79 }
80 
dump(std::string & result,bool less) const81 void GraphicBufferAllocator::dump(std::string& result, bool less) const {
82     Mutex::Autolock _l(sLock);
83     KeyedVector<buffer_handle_t, alloc_rec_t>& list(sAllocList);
84     uint64_t total = 0;
85     result.append("GraphicBufferAllocator buffers:\n");
86     const size_t c = list.size();
87     for (size_t i=0 ; i<c ; i++) {
88         const alloc_rec_t& rec(list.valueAt(i));
89         if (rec.size) {
90             StringAppendF(&result,
91                           "%10p: %7.2f KiB | %4u (%4u) x %4u | %4u | %8X | 0x%" PRIx64 " | %s\n",
92                           list.keyAt(i), static_cast<double>(rec.size) / 1024.0, rec.width, rec.stride, rec.height,
93                           rec.layerCount, rec.format, rec.usage, rec.requestorName.c_str());
94         } else {
95             StringAppendF(&result,
96                           "%10p: unknown     | %4u (%4u) x %4u | %4u | %8X | 0x%" PRIx64 " | %s\n",
97                           list.keyAt(i), rec.width, rec.stride, rec.height, rec.layerCount,
98                           rec.format, rec.usage, rec.requestorName.c_str());
99         }
100         total += rec.size;
101     }
102     StringAppendF(&result, "Total allocated by GraphicBufferAllocator (estimate): %.2f KB\n",
103                   static_cast<double>(total) / 1024.0);
104 
105     result.append(mAllocator->dumpDebugInfo(less));
106 }
107 
dumpToSystemLog(bool less)108 void GraphicBufferAllocator::dumpToSystemLog(bool less) {
109     std::string s;
110     GraphicBufferAllocator::getInstance().dump(s, less);
111     ALOGD("%s", s.c_str());
112 }
113 
allocateHelper(uint32_t width,uint32_t height,PixelFormat format,uint32_t layerCount,uint64_t usage,buffer_handle_t * handle,uint32_t * stride,std::string requestorName,bool importBuffer)114 status_t GraphicBufferAllocator::allocateHelper(uint32_t width, uint32_t height, PixelFormat format,
115                                                 uint32_t layerCount, uint64_t usage,
116                                                 buffer_handle_t* handle, uint32_t* stride,
117                                                 std::string requestorName, bool importBuffer) {
118     ATRACE_CALL();
119 
120     // make sure to not allocate a N x 0 or 0 x N buffer, since this is
121     // allowed from an API stand-point allocate a 1x1 buffer instead.
122     if (!width || !height)
123         width = height = 1;
124 
125     const uint32_t bpp = bytesPerPixel(format);
126     if (std::numeric_limits<size_t>::max() / width / height < static_cast<size_t>(bpp)) {
127         ALOGE("Failed to allocate (%u x %u) layerCount %u format %d "
128               "usage %" PRIx64 ": Requesting too large a buffer size",
129               width, height, layerCount, format, usage);
130         return BAD_VALUE;
131     }
132 
133     // Ensure that layerCount is valid.
134     if (layerCount < 1)
135         layerCount = 1;
136 
137     // TODO(b/72323293, b/72703005): Remove these invalid bits from callers
138     usage &= ~static_cast<uint64_t>((1 << 10) | (1 << 13));
139 
140     status_t error = mAllocator->allocate(requestorName, width, height, format, layerCount, usage,
141                                           1, stride, handle, importBuffer);
142     if (error != NO_ERROR) {
143         ALOGE("Failed to allocate (%u x %u) layerCount %u format %d "
144               "usage %" PRIx64 ": %d",
145               width, height, layerCount, format, usage, error);
146         return NO_MEMORY;
147     }
148 
149     if (!importBuffer) {
150         return NO_ERROR;
151     }
152     size_t bufSize;
153 
154     // if stride has no meaning or is too large,
155     // approximate size with the input width instead
156     if ((*stride) != 0 &&
157         std::numeric_limits<size_t>::max() / height / (*stride) < static_cast<size_t>(bpp)) {
158         bufSize = static_cast<size_t>(width) * height * bpp;
159     } else {
160         bufSize = static_cast<size_t>((*stride)) * height * bpp;
161     }
162 
163     Mutex::Autolock _l(sLock);
164     KeyedVector<buffer_handle_t, alloc_rec_t>& list(sAllocList);
165     alloc_rec_t rec;
166     rec.width = width;
167     rec.height = height;
168     rec.stride = *stride;
169     rec.format = format;
170     rec.layerCount = layerCount;
171     rec.usage = usage;
172     rec.size = bufSize;
173     rec.requestorName = std::move(requestorName);
174     list.add(*handle, rec);
175 
176     return NO_ERROR;
177 }
allocate(uint32_t width,uint32_t height,PixelFormat format,uint32_t layerCount,uint64_t usage,buffer_handle_t * handle,uint32_t * stride,std::string requestorName)178 status_t GraphicBufferAllocator::allocate(uint32_t width, uint32_t height, PixelFormat format,
179                                           uint32_t layerCount, uint64_t usage,
180                                           buffer_handle_t* handle, uint32_t* stride,
181                                           std::string requestorName) {
182     return allocateHelper(width, height, format, layerCount, usage, handle, stride, requestorName,
183                           true);
184 }
185 
allocateRawHandle(uint32_t width,uint32_t height,PixelFormat format,uint32_t layerCount,uint64_t usage,buffer_handle_t * handle,uint32_t * stride,std::string requestorName)186 status_t GraphicBufferAllocator::allocateRawHandle(uint32_t width, uint32_t height,
187                                                    PixelFormat format, uint32_t layerCount,
188                                                    uint64_t usage, buffer_handle_t* handle,
189                                                    uint32_t* stride, std::string requestorName) {
190     return allocateHelper(width, height, format, layerCount, usage, handle, stride, requestorName,
191                           false);
192 }
193 
194 // DEPRECATED
allocate(uint32_t width,uint32_t height,PixelFormat format,uint32_t layerCount,uint64_t usage,buffer_handle_t * handle,uint32_t * stride,uint64_t,std::string requestorName)195 status_t GraphicBufferAllocator::allocate(uint32_t width, uint32_t height, PixelFormat format,
196                                           uint32_t layerCount, uint64_t usage,
197                                           buffer_handle_t* handle, uint32_t* stride,
198                                           uint64_t /*graphicBufferId*/, std::string requestorName) {
199     return allocateHelper(width, height, format, layerCount, usage, handle, stride, requestorName,
200                           true);
201 }
202 
free(buffer_handle_t handle)203 status_t GraphicBufferAllocator::free(buffer_handle_t handle)
204 {
205     ATRACE_CALL();
206 
207     // We allocated a buffer from the allocator and imported it into the
208     // mapper to get the handle.  We just need to free the handle now.
209     mMapper.freeBuffer(handle);
210 
211     Mutex::Autolock _l(sLock);
212     KeyedVector<buffer_handle_t, alloc_rec_t>& list(sAllocList);
213     list.removeItem(handle);
214 
215     return NO_ERROR;
216 }
217 
218 // ---------------------------------------------------------------------------
219 }; // namespace android
220