1 /*
2  * Copyright (C) 2015 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 #include "rs.h"
18 #include "rsDevice.h"
19 #include "rsContext.h"
20 #include "rsThreadIO.h"
21 
22 #include "rsgApiStructs.h"
23 
24 #ifndef RS_COMPATIBILITY_LIB
25 #include "rsMesh.h"
26 #include <gui/DisplayEventReceiver.h>
27 #endif
28 
29 #include <sys/types.h>
30 #include <sys/resource.h>
31 #include <sched.h>
32 
33 #include <sys/syscall.h>
34 #include <string.h>
35 #include <dlfcn.h>
36 #include <inttypes.h>
37 #include <unistd.h>
38 
39 #if !defined(RS_SERVER) && !defined(RS_COMPATIBILITY_LIB) && \
40         defined(__ANDROID__)
41 #include <cutils/properties.h>
42 #endif
43 
44 #ifdef RS_COMPATIBILITY_LIB
45 #include "rsCompatibilityLib.h"
46 #endif
47 
48 using namespace android;
49 using namespace android::renderscript;
50 
51 
52 
53 typedef bool (*HalQueryVersion)(uint32_t *version_major, uint32_t *version_minor);
54 typedef bool (*HalQueryHal)(android::renderscript::RsHalInitEnums entry, void **fnPtr);
55 typedef bool (*HalInit)(RsContext, uint32_t version_major, uint32_t version_minor);
56 typedef void (*HalAbort)(RsContext);
57 
58 
LoadHalTable(Context * rsc,HalQueryHal fn,bool loadGraphics)59 static bool LoadHalTable(Context *rsc, HalQueryHal fn, bool loadGraphics) {
60     bool ret = true;
61 
62     ret &= fn(RS_HAL_CORE_SHUTDOWN, (void **)&rsc->mHal.funcs.shutdownDriver);
63     ret &= fn(RS_HAL_CORE_SET_PRIORITY, (void **)&rsc->mHal.funcs.setPriority);
64     ret &= fn(RS_HAL_CORE_ALLOC_RUNTIME_MEM, (void **)&rsc->mHal.funcs.allocRuntimeMem);
65     ret &= fn(RS_HAL_CORE_FREE_RUNTIME_MEM, (void **)&rsc->mHal.funcs.freeRuntimeMem);
66     ret &= fn(RS_HAL_CORE_FINISH, (void **)&rsc->mHal.funcs.finish);
67 
68     ret &= fn(RS_HAL_SCRIPT_INIT, (void **)&rsc->mHal.funcs.script.init);
69     ret &= fn(RS_HAL_SCRIPT_INIT_INTRINSIC, (void **)&rsc->mHal.funcs.script.initIntrinsic);
70     ret &= fn(RS_HAL_SCRIPT_INVOKE_FUNCTION, (void **)&rsc->mHal.funcs.script.invokeFunction);
71     ret &= fn(RS_HAL_SCRIPT_INVOKE_ROOT, (void **)&rsc->mHal.funcs.script.invokeRoot);
72     ret &= fn(RS_HAL_SCRIPT_INVOKE_FOR_EACH, (void **)&rsc->mHal.funcs.script.invokeForEach);
73     ret &= fn(RS_HAL_SCRIPT_INVOKE_REDUCE, (void **)&rsc->mHal.funcs.script.invokeReduce);
74     ret &= fn(RS_HAL_SCRIPT_INVOKE_INIT, (void **)&rsc->mHal.funcs.script.invokeInit);
75     ret &= fn(RS_HAL_SCRIPT_INVOKE_FREE_CHILDREN, (void **)&rsc->mHal.funcs.script.invokeFreeChildren);
76     ret &= fn(RS_HAL_SCRIPT_SET_GLOBAL_VAR, (void **)&rsc->mHal.funcs.script.setGlobalVar);
77     ret &= fn(RS_HAL_SCRIPT_GET_GLOBAL_VAR, (void **)&rsc->mHal.funcs.script.getGlobalVar);
78     ret &= fn(RS_HAL_SCRIPT_SET_GLOBAL_VAR_WITH_ELEMENT_DIM, (void **)&rsc->mHal.funcs.script.setGlobalVarWithElemDims);
79     ret &= fn(RS_HAL_SCRIPT_SET_GLOBAL_BIND, (void **)&rsc->mHal.funcs.script.setGlobalBind);
80     ret &= fn(RS_HAL_SCRIPT_SET_GLOBAL_OBJECT, (void **)&rsc->mHal.funcs.script.setGlobalObj);
81     ret &= fn(RS_HAL_SCRIPT_DESTROY, (void **)&rsc->mHal.funcs.script.destroy);
82     ret &= fn(RS_HAL_SCRIPT_INVOKE_FOR_EACH_MULTI, (void **)&rsc->mHal.funcs.script.invokeForEachMulti);
83     ret &= fn(RS_HAL_SCRIPT_UPDATE_CACHED_OBJECT, (void **)&rsc->mHal.funcs.script.updateCachedObject);
84 
85     ret &= fn(RS_HAL_ALLOCATION_INIT, (void **)&rsc->mHal.funcs.allocation.init);
86     ret &= fn(RS_HAL_ALLOCATION_INIT_OEM, (void **)&rsc->mHal.funcs.allocation.initOem);
87     ret &= fn(RS_HAL_ALLOCATION_INIT_ADAPTER, (void **)&rsc->mHal.funcs.allocation.initAdapter);
88     ret &= fn(RS_HAL_ALLOCATION_DESTROY, (void **)&rsc->mHal.funcs.allocation.destroy);
89     ret &= fn(RS_HAL_ALLOCATION_GET_GRALLOC_BITS, (void **)&rsc->mHal.funcs.allocation.grallocBits);
90     ret &= fn(RS_HAL_ALLOCATION_RESIZE, (void **)&rsc->mHal.funcs.allocation.resize);
91     ret &= fn(RS_HAL_ALLOCATION_SYNC_ALL, (void **)&rsc->mHal.funcs.allocation.syncAll);
92     ret &= fn(RS_HAL_ALLOCATION_MARK_DIRTY, (void **)&rsc->mHal.funcs.allocation.markDirty);
93     ret &= fn(RS_HAL_ALLOCATION_SET_SURFACE, (void **)&rsc->mHal.funcs.allocation.setSurface);
94     ret &= fn(RS_HAL_ALLOCATION_IO_SEND, (void **)&rsc->mHal.funcs.allocation.ioSend);
95     ret &= fn(RS_HAL_ALLOCATION_IO_RECEIVE, (void **)&rsc->mHal.funcs.allocation.ioReceive);
96     ret &= fn(RS_HAL_ALLOCATION_DATA_1D, (void **)&rsc->mHal.funcs.allocation.data1D);
97     ret &= fn(RS_HAL_ALLOCATION_DATA_2D, (void **)&rsc->mHal.funcs.allocation.data2D);
98     ret &= fn(RS_HAL_ALLOCATION_DATA_3D, (void **)&rsc->mHal.funcs.allocation.data3D);
99     ret &= fn(RS_HAL_ALLOCATION_READ_1D, (void **)&rsc->mHal.funcs.allocation.read1D);
100     ret &= fn(RS_HAL_ALLOCATION_READ_2D, (void **)&rsc->mHal.funcs.allocation.read2D);
101     ret &= fn(RS_HAL_ALLOCATION_READ_3D, (void **)&rsc->mHal.funcs.allocation.read3D);
102     ret &= fn(RS_HAL_ALLOCATION_LOCK_1D, (void **)&rsc->mHal.funcs.allocation.lock1D);
103     ret &= fn(RS_HAL_ALLOCATION_UNLOCK_1D, (void **)&rsc->mHal.funcs.allocation.unlock1D);
104     ret &= fn(RS_HAL_ALLOCATION_COPY_1D, (void **)&rsc->mHal.funcs.allocation.allocData1D);
105     ret &= fn(RS_HAL_ALLOCATION_COPY_2D, (void **)&rsc->mHal.funcs.allocation.allocData2D);
106     ret &= fn(RS_HAL_ALLOCATION_COPY_3D, (void **)&rsc->mHal.funcs.allocation.allocData3D);
107     ret &= fn(RS_HAL_ALLOCATION_ELEMENT_DATA, (void **)&rsc->mHal.funcs.allocation.elementData);
108     ret &= fn(RS_HAL_ALLOCATION_ELEMENT_READ, (void **)&rsc->mHal.funcs.allocation.elementRead);
109     ret &= fn(RS_HAL_ALLOCATION_GENERATE_MIPMAPS, (void **)&rsc->mHal.funcs.allocation.generateMipmaps);
110     ret &= fn(RS_HAL_ALLOCATION_UPDATE_CACHED_OBJECT, (void **)&rsc->mHal.funcs.allocation.updateCachedObject);
111     ret &= fn(RS_HAL_ALLOCATION_ADAPTER_OFFSET, (void **)&rsc->mHal.funcs.allocation.adapterOffset);
112     ret &= fn(RS_HAL_ALLOCATION_GET_POINTER, (void **)&rsc->mHal.funcs.allocation.getPointer);
113 #ifdef RS_COMPATIBILITY_LIB
114     ret &= fn(RS_HAL_ALLOCATION_INIT_STRIDED, (void **)&rsc->mHal.funcs.allocation.initStrided);
115 #endif
116 
117     ret &= fn(RS_HAL_SAMPLER_INIT, (void **)&rsc->mHal.funcs.sampler.init);
118     ret &= fn(RS_HAL_SAMPLER_DESTROY, (void **)&rsc->mHal.funcs.sampler.destroy);
119     ret &= fn(RS_HAL_SAMPLER_UPDATE_CACHED_OBJECT, (void **)&rsc->mHal.funcs.sampler.updateCachedObject);
120 
121     ret &= fn(RS_HAL_TYPE_INIT, (void **)&rsc->mHal.funcs.type.init);
122     ret &= fn(RS_HAL_TYPE_DESTROY, (void **)&rsc->mHal.funcs.type.destroy);
123     ret &= fn(RS_HAL_TYPE_UPDATE_CACHED_OBJECT, (void **)&rsc->mHal.funcs.type.updateCachedObject);
124 
125     ret &= fn(RS_HAL_ELEMENT_INIT, (void **)&rsc->mHal.funcs.element.init);
126     ret &= fn(RS_HAL_ELEMENT_DESTROY, (void **)&rsc->mHal.funcs.element.destroy);
127     ret &= fn(RS_HAL_ELEMENT_UPDATE_CACHED_OBJECT, (void **)&rsc->mHal.funcs.element.updateCachedObject);
128 
129     ret &= fn(RS_HAL_SCRIPT_GROUP_INIT, (void **)&rsc->mHal.funcs.scriptgroup.init);
130     ret &= fn(RS_HAL_SCRIPT_GROUP_DESTROY, (void **)&rsc->mHal.funcs.scriptgroup.destroy);
131     ret &= fn(RS_HAL_SCRIPT_GROUP_UPDATE_CACHED_OBJECT, (void **)&rsc->mHal.funcs.scriptgroup.updateCachedObject);
132     ret &= fn(RS_HAL_SCRIPT_GROUP_SET_INPUT, (void **)&rsc->mHal.funcs.scriptgroup.setInput);
133     ret &= fn(RS_HAL_SCRIPT_GROUP_SET_OUTPUT, (void **)&rsc->mHal.funcs.scriptgroup.setOutput);
134     ret &= fn(RS_HAL_SCRIPT_GROUP_EXECUTE, (void **)&rsc->mHal.funcs.scriptgroup.execute);
135 
136 
137     if (loadGraphics) {
138         ret &= fn(RS_HAL_GRAPHICS_INIT, (void **)&rsc->mHal.funcs.initGraphics);
139         ret &= fn(RS_HAL_GRAPHICS_SHUTDOWN, (void **)&rsc->mHal.funcs.shutdownGraphics);
140         ret &= fn(RS_HAL_GRAPHICS_SWAP, (void **)&rsc->mHal.funcs.swap);
141         ret &= fn(RS_HAL_GRAPHICS_SET_SURFACE, (void **)&rsc->mHal.funcs.setSurface);
142         ret &= fn(RS_HAL_GRAPHICS_RASTER_INIT, (void **)&rsc->mHal.funcs.raster.init);
143         ret &= fn(RS_HAL_GRAPHICS_RASTER_SET_ACTIVE, (void **)&rsc->mHal.funcs.raster.setActive);
144         ret &= fn(RS_HAL_GRAPHICS_RASTER_DESTROY, (void **)&rsc->mHal.funcs.raster.destroy);
145         ret &= fn(RS_HAL_GRAPHICS_VERTEX_INIT, (void **)&rsc->mHal.funcs.vertex.init);
146         ret &= fn(RS_HAL_GRAPHICS_VERTEX_SET_ACTIVE, (void **)&rsc->mHal.funcs.vertex.setActive);
147         ret &= fn(RS_HAL_GRAPHICS_VERTEX_DESTROY, (void **)&rsc->mHal.funcs.vertex.destroy);
148         ret &= fn(RS_HAL_GRAPHICS_FRAGMENT_INIT, (void **)&rsc->mHal.funcs.fragment.init);
149         ret &= fn(RS_HAL_GRAPHICS_FRAGMENT_SET_ACTIVE, (void **)&rsc->mHal.funcs.fragment.setActive);
150         ret &= fn(RS_HAL_GRAPHICS_FRAGMENT_DESTROY, (void **)&rsc->mHal.funcs.fragment.destroy);
151         ret &= fn(RS_HAL_GRAPHICS_MESH_INIT, (void **)&rsc->mHal.funcs.mesh.init);
152         ret &= fn(RS_HAL_GRAPHICS_MESH_DRAW, (void **)&rsc->mHal.funcs.mesh.draw);
153         ret &= fn(RS_HAL_GRAPHICS_MESH_DESTROY, (void **)&rsc->mHal.funcs.mesh.destroy);
154         ret &= fn(RS_HAL_GRAPHICS_FB_INIT, (void **)&rsc->mHal.funcs.framebuffer.init);
155         ret &= fn(RS_HAL_GRAPHICS_FB_SET_ACTIVE, (void **)&rsc->mHal.funcs.framebuffer.setActive);
156         ret &= fn(RS_HAL_GRAPHICS_FB_DESTROY, (void **)&rsc->mHal.funcs.framebuffer.destroy);
157         ret &= fn(RS_HAL_GRAPHICS_STORE_INIT, (void **)&rsc->mHal.funcs.store.init);
158         ret &= fn(RS_HAL_GRAPHICS_STORE_SET_ACTIVE, (void **)&rsc->mHal.funcs.store.setActive);
159         ret &= fn(RS_HAL_GRAPHICS_STORE_DESTROY, (void **)&rsc->mHal.funcs.store.destroy);
160     }
161 
162     return ret;
163 }
164 
loadRuntime(const char * filename)165 bool Context::loadRuntime(const char* filename) {
166     HalQueryVersion fnQueryVersion = nullptr;
167     HalQueryHal fnQueryHal = nullptr;
168     HalInit fnInit = nullptr;
169     HalAbort fnAbort = nullptr;
170 
171 
172     // TODO: store the driverSO somewhere so we can dlclose later
173     void *driverSO = nullptr;
174 
175     driverSO = dlopen(filename, RTLD_LAZY);
176     if (driverSO == nullptr) {
177         ALOGE("Failed loading RS driver: %s", dlerror());
178         return false;
179     }
180 
181     // Need to call dlerror() to clear buffer before using it for dlsym().
182     (void) dlerror();
183 
184     fnQueryVersion = (HalQueryVersion) dlsym(driverSO, "rsdHalQueryVersion");
185     fnQueryHal = (HalQueryHal) dlsym(driverSO, "rsdHalQueryHal");
186     fnInit = (HalInit) dlsym(driverSO, "rsdHalInit");
187     fnAbort = (HalAbort) dlsym(driverSO, "rsdHalAbort");
188     uint32_t version_major = 0;
189     uint32_t version_minor = 0;
190 
191     if ((fnQueryVersion == nullptr) || (fnQueryHal == nullptr) ||
192         (fnInit == nullptr) || (fnAbort == nullptr)) {
193 
194         ALOGE("Failed to find hal setup entry points: %s", dlerror());
195         goto error;
196     }
197 
198     if (!fnQueryVersion(&version_major, &version_minor)) {
199         ALOGE("Error checking RS driver version, %s", filename);
200         goto error;
201     }
202 
203     if (version_major != RS_HAL_VERSION) {
204         ALOGE("Mismatched RS HAL versions: %s is version %u but version %u is expected",
205               filename, version_major, RS_HAL_VERSION);
206         goto error;
207     }
208 
209     if (!LoadHalTable(this, fnQueryHal, mIsGraphicsContext)) {
210         ALOGE("Error loading RS HAL table, %s", filename);
211         goto error;
212     }
213 
214     if (!(*fnInit)(this, 0, 0)) {
215         ALOGE("Hal init failed,  %s", filename);
216         goto error;
217     }
218 
219     // Only map in the actual driver name if we successfully load the runtime.
220     setDriverName(filename);
221 
222     return true;
223 
224 
225 error:
226     if (fnAbort != nullptr) {
227         fnAbort(this);
228     }
229     dlclose(driverSO);
230     return false;
231 }
232 
233 
234 
loadDriver(bool forceDefault)235 bool Context::loadDriver(bool forceDefault) {
236     bool loadDefault = true;
237 
238     // Provide a mechanism for dropping in a different RS driver.
239 #ifndef RS_COMPATIBILITY_LIB
240 #ifdef OVERRIDE_RS_DRIVER
241 #define XSTR(S) #S
242 #define STR(S) XSTR(S)
243 #define OVERRIDE_RS_DRIVER_STRING STR(OVERRIDE_RS_DRIVER)
244 
245     if (!forceDefault) {
246         if (loadRuntime(OVERRIDE_RS_DRIVER_STRING)) {
247             ALOGV("Successfully loaded runtime: %s", OVERRIDE_RS_DRIVER_STRING);
248             loadDefault = false;
249         } else {
250             ALOGE("Failed to load runtime %s, loading default", OVERRIDE_RS_DRIVER_STRING);
251         }
252     }
253 #undef XSTR
254 #undef STR
255 #endif  // OVERRIDE_RS_DRIVER
256 
257     if (loadDefault) {
258         if (!loadRuntime("libRSDriver.so")) {
259             ALOGE("Failed to load default runtime!");
260             return false;
261         }
262     }
263 #else // RS_COMPATIBILITY_LIB
264     if (!LoadHalTable(this, rsdHalQueryHal, false)) {
265         ALOGE("Error loading RS HAL table");
266         return false;
267     }
268     if (rsdHalInit(this, 0, 0) != true) {
269         return false;
270     }
271 #endif
272 
273     return true;
274 }
275