rsCpuExecutable.cpp revision 062c287f573ecc06c38ee4295e5627e12c52ac3d 
1#include "rsCpuExecutable.h"
2#include "rsCppUtils.h"
3
4#include <fstream>
5#include <set>
6#include <memory>
7
8#ifdef RS_COMPATIBILITY_LIB
9#include <stdio.h>
10#include <sys/stat.h>
11#include <unistd.h>
12#else
13#include "bcc/Config/Config.h"
14#include <bcc/Renderscript/RSInfo.h>
15#include <sys/wait.h>
16#endif
17
18#include <dlfcn.h>
19
20namespace android {
21namespace renderscript {
22
23namespace {
24
25// Create a len length string containing random characters from [A-Za-z0-9].
26static std::string getRandomString(size_t len) {
27    char buf[len + 1];
28    for (size_t i = 0; i < len; i++) {
29        uint32_t r = arc4random() & 0xffff;
30        r %= 62;
31        if (r < 26) {
32            // lowercase
33            buf[i] = 'a' + r;
34        } else if (r < 52) {
35            // uppercase
36            buf[i] = 'A' + (r - 26);
37        } else {
38            // Use a number
39            buf[i] = '0' + (r - 52);
40        }
41    }
42    buf[len] = '\0';
43    return std::string(buf);
44}
45
46// Check if a path exists and attempt to create it if it doesn't.
47static bool ensureCacheDirExists(const char *path) {
48    if (access(path, R_OK | W_OK | X_OK) == 0) {
49        // Done if we can rwx the directory
50        return true;
51    }
52    if (mkdir(path, 0700) == 0) {
53        return true;
54    }
55    return false;
56}
57
58// Copy the file named \p srcFile to \p dstFile.
59// Return 0 on success and -1 if anything wasn't copied.
60static int copyFile(const char *dstFile, const char *srcFile) {
61    std::ifstream srcStream(srcFile);
62    if (!srcStream) {
63        ALOGE("Could not verify or read source file: %s", srcFile);
64        return -1;
65    }
66    std::ofstream dstStream(dstFile);
67    if (!dstStream) {
68        ALOGE("Could not verify or write destination file: %s", dstFile);
69        return -1;
70    }
71    dstStream << srcStream.rdbuf();
72    if (!dstStream) {
73        ALOGE("Could not write destination file: %s", dstFile);
74        return -1;
75    }
76
77    srcStream.close();
78    dstStream.close();
79
80    return 0;
81}
82
83static std::string findSharedObjectName(const char *cacheDir,
84                                        const char *resName) {
85#ifndef RS_SERVER
86    std::string scriptSOName(cacheDir);
87#if defined(RS_COMPATIBILITY_LIB) && !defined(__LP64__)
88    size_t cutPos = scriptSOName.rfind("cache");
89    if (cutPos != std::string::npos) {
90        scriptSOName.erase(cutPos);
91    } else {
92        ALOGE("Found peculiar cacheDir (missing \"cache\"): %s", cacheDir);
93    }
94    scriptSOName.append("/lib/librs.");
95#else
96    scriptSOName.append("/librs.");
97#endif // RS_COMPATIBILITY_LIB
98
99#else
100    std::string scriptSOName("lib");
101#endif // RS_SERVER
102    scriptSOName.append(resName);
103    scriptSOName.append(".so");
104
105    return scriptSOName;
106}
107
108}  // anonymous namespace
109
110const char* SharedLibraryUtils::LD_EXE_PATH = "/system/bin/ld.mc";
111const char* SharedLibraryUtils::RS_CACHE_DIR = "com.android.renderscript.cache";
112
113#ifndef RS_COMPATIBILITY_LIB
114
115bool SharedLibraryUtils::createSharedLibrary(const char *cacheDir, const char *resName) {
116    std::string sharedLibName = findSharedObjectName(cacheDir, resName);
117    std::string objFileName = cacheDir;
118    objFileName.append("/");
119    objFileName.append(resName);
120    objFileName.append(".o");
121
122    const char *compiler_rt = SYSLIBPATH"/libcompiler_rt.so";
123    std::vector<const char *> args = {
124        LD_EXE_PATH,
125        "-shared",
126        "-nostdlib",
127        compiler_rt,
128        "-mtriple", DEFAULT_TARGET_TRIPLE_STRING,
129        "-L", SYSLIBPATH,
130        "-lRSDriver", "-lm", "-lc",
131        objFileName.c_str(),
132        "-o", sharedLibName.c_str(),
133        nullptr
134    };
135
136    std::unique_ptr<const char> joined(
137        rsuJoinStrings(args.size()-1, args.data()));
138    std::string cmdLineStr (joined.get());
139
140    pid_t pid = fork();
141
142    switch (pid) {
143    case -1: {  // Error occurred (we attempt no recovery)
144        ALOGE("Couldn't fork for linker (%s) execution", LD_EXE_PATH);
145        return false;
146    }
147    case 0: {  // Child process
148        ALOGV("Invoking ld.mc with args '%s'", cmdLineStr.c_str());
149        execv(LD_EXE_PATH, (char* const*) args.data());
150
151        ALOGE("execv() failed: %s", strerror(errno));
152        abort();
153        return false;
154    }
155    default: {  // Parent process (actual driver)
156        // Wait on child process to finish compiling the source.
157        int status = 0;
158        pid_t w = waitpid(pid, &status, 0);
159        if (w == -1) {
160            ALOGE("Could not wait for linker (%s)", LD_EXE_PATH);
161            return false;
162        }
163
164        if (WIFEXITED(status) && WEXITSTATUS(status) == 0) {
165            return true;
166        }
167
168        ALOGE("Linker (%s) terminated unexpectedly", LD_EXE_PATH);
169        return false;
170    }
171    }
172}
173
174#endif  // RS_COMPATIBILITY_LIB
175
176const char* RsdCpuScriptImpl::BCC_EXE_PATH = "/system/bin/bcc";
177
178void* SharedLibraryUtils::loadSharedLibrary(const char *cacheDir,
179                                            const char *resName,
180                                            const char *nativeLibDir) {
181    void *loaded = nullptr;
182
183#if defined(RS_COMPATIBILITY_LIB) && defined(__LP64__)
184    std::string scriptSOName = findSharedObjectName(nativeLibDir, resName);
185#else
186    std::string scriptSOName = findSharedObjectName(cacheDir, resName);
187#endif
188
189    // We should check if we can load the library from the standard app
190    // location for shared libraries first.
191    loaded = loadSOHelper(scriptSOName.c_str(), cacheDir, resName);
192
193    if (loaded == nullptr) {
194        ALOGE("Unable to open shared library (%s): %s",
195              scriptSOName.c_str(), dlerror());
196
197#ifdef RS_COMPATIBILITY_LIB
198        // One final attempt to find the library in "/system/lib".
199        // We do this to allow bundled applications to use the compatibility
200        // library fallback path. Those applications don't have a private
201        // library path, so they need to install to the system directly.
202        // Note that this is really just a testing path.
203        std::string scriptSONameSystem("/system/lib/librs.");
204        scriptSONameSystem.append(resName);
205        scriptSONameSystem.append(".so");
206        loaded = loadSOHelper(scriptSONameSystem.c_str(), cacheDir,
207                              resName);
208        if (loaded == nullptr) {
209            ALOGE("Unable to open system shared library (%s): %s",
210                  scriptSONameSystem.c_str(), dlerror());
211        }
212#endif
213    }
214
215    return loaded;
216}
217
218void* SharedLibraryUtils::loadSOHelper(const char *origName, const char *cacheDir,
219                                       const char *resName) {
220    // Keep track of which .so libraries have been loaded. Once a library is
221    // in the set (per-process granularity), we must instead make a copy of
222    // the original shared object (randomly named .so file) and load that one
223    // instead. If we don't do this, we end up aliasing global data between
224    // the various Script instances (which are supposed to be completely
225    // independent).
226    static std::set<std::string> LoadedLibraries;
227
228    void *loaded = nullptr;
229
230    // Skip everything if we don't even have the original library available.
231    if (access(origName, F_OK) != 0) {
232        return nullptr;
233    }
234
235    // Common path is that we have not loaded this Script/library before.
236    if (LoadedLibraries.find(origName) == LoadedLibraries.end()) {
237        loaded = dlopen(origName, RTLD_NOW | RTLD_LOCAL);
238        if (loaded) {
239            LoadedLibraries.insert(origName);
240        }
241        return loaded;
242    }
243
244    std::string newName(cacheDir);
245
246    // Append RS_CACHE_DIR only if it is not found in cacheDir
247    // In driver mode, RS_CACHE_DIR is already appended to cacheDir.
248    if (newName.find(RS_CACHE_DIR) == std::string::npos) {
249        newName.append("/");
250        newName.append(RS_CACHE_DIR);
251        newName.append("/");
252    }
253
254    if (!ensureCacheDirExists(newName.c_str())) {
255        ALOGE("Could not verify or create cache dir: %s", cacheDir);
256        return nullptr;
257    }
258
259    // Construct an appropriately randomized filename for the copy.
260    newName.append("librs.");
261    newName.append(resName);
262    newName.append("#");
263    newName.append(getRandomString(6));  // 62^6 potential filename variants.
264    newName.append(".so");
265
266    int r = copyFile(newName.c_str(), origName);
267    if (r != 0) {
268        ALOGE("Could not create copy %s -> %s", origName, newName.c_str());
269        return nullptr;
270    }
271    loaded = dlopen(newName.c_str(), RTLD_NOW | RTLD_LOCAL);
272    r = unlink(newName.c_str());
273    if (r != 0) {
274        ALOGE("Could not unlink copy %s", newName.c_str());
275    }
276    if (loaded) {
277        LoadedLibraries.insert(newName.c_str());
278    }
279
280    return loaded;
281}
282
283#define MAXLINE 500
284#define MAKE_STR_HELPER(S) #S
285#define MAKE_STR(S) MAKE_STR_HELPER(S)
286#define EXPORT_VAR_STR "exportVarCount: "
287#define EXPORT_FUNC_STR "exportFuncCount: "
288#define EXPORT_FOREACH_STR "exportForEachCount: "
289#define OBJECT_SLOT_STR "objectSlotCount: "
290#define PRAGMA_STR "pragmaCount: "
291#define THREADABLE_STR "isThreadable: "
292#define CHECKSUM_STR "buildChecksum: "
293
294// Copy up to a newline or size chars from str -> s, updating str
295// Returns s when successful and nullptr when '\0' is finally reached.
296static char* strgets(char *s, int size, const char **ppstr) {
297    if (!ppstr || !*ppstr || **ppstr == '\0' || size < 1) {
298        return nullptr;
299    }
300
301    int i;
302    for (i = 0; i < (size - 1); i++) {
303        s[i] = **ppstr;
304        (*ppstr)++;
305        if (s[i] == '\0') {
306            return s;
307        } else if (s[i] == '\n') {
308            s[i+1] = '\0';
309            return s;
310        }
311    }
312
313    // size has been exceeded.
314    s[i] = '\0';
315
316    return s;
317}
318
319ScriptExecutable* ScriptExecutable::createFromSharedObject(
320    Context* RSContext, void* sharedObj) {
321    char line[MAXLINE];
322
323    size_t varCount = 0;
324    size_t funcCount = 0;
325    size_t forEachCount = 0;
326    size_t objectSlotCount = 0;
327    size_t pragmaCount = 0;
328    bool isThreadable = true;
329
330    void** fieldAddress = nullptr;
331    bool* fieldIsObject = nullptr;
332    char** fieldName = nullptr;
333    InvokeFunc_t* invokeFunctions = nullptr;
334    ForEachFunc_t* forEachFunctions = nullptr;
335    uint32_t* forEachSignatures = nullptr;
336    const char ** pragmaKeys = nullptr;
337    const char ** pragmaValues = nullptr;
338    char *checksum = nullptr;
339
340    const char *rsInfo = (const char *) dlsym(sharedObj, ".rs.info");
341
342    if (strgets(line, MAXLINE, &rsInfo) == nullptr) {
343        return nullptr;
344    }
345    if (sscanf(line, EXPORT_VAR_STR "%zu", &varCount) != 1) {
346        ALOGE("Invalid export var count!: %s", line);
347        return nullptr;
348    }
349
350    fieldAddress = new void*[varCount];
351    if (fieldAddress == nullptr) {
352        return nullptr;
353    }
354
355    fieldIsObject = new bool[varCount];
356    if (fieldIsObject == nullptr) {
357        goto error;
358    }
359
360    fieldName = new char*[varCount];
361    if (fieldName == nullptr) {
362        goto error;
363    }
364
365    for (size_t i = 0; i < varCount; ++i) {
366        if (strgets(line, MAXLINE, &rsInfo) == nullptr) {
367            goto error;
368        }
369        char *c = strrchr(line, '\n');
370        if (c) {
371            *c = '\0';
372        }
373        void* addr = dlsym(sharedObj, line);
374        if (addr == nullptr) {
375            ALOGE("Failed to find variable address for %s: %s",
376                  line, dlerror());
377            // Not a critical error if we don't find a global variable.
378        }
379        fieldAddress[i] = addr;
380        fieldIsObject[i] = false;
381        fieldName[i] = new char[strlen(line)+1];
382        strcpy(fieldName[i], line);
383    }
384
385    if (strgets(line, MAXLINE, &rsInfo) == nullptr) {
386        goto error;
387    }
388    if (sscanf(line, EXPORT_FUNC_STR "%zu", &funcCount) != 1) {
389        ALOGE("Invalid export func count!: %s", line);
390        goto error;
391    }
392
393    invokeFunctions = new InvokeFunc_t[funcCount];
394    if (invokeFunctions == nullptr) {
395        goto error;
396    }
397
398    for (size_t i = 0; i < funcCount; ++i) {
399        if (strgets(line, MAXLINE, &rsInfo) == nullptr) {
400            goto error;
401        }
402        char *c = strrchr(line, '\n');
403        if (c) {
404            *c = '\0';
405        }
406
407        invokeFunctions[i] = (InvokeFunc_t) dlsym(sharedObj, line);
408        if (invokeFunctions[i] == nullptr) {
409            ALOGE("Failed to get function address for %s(): %s",
410                  line, dlerror());
411            goto error;
412        }
413    }
414
415    if (strgets(line, MAXLINE, &rsInfo) == nullptr) {
416        goto error;
417    }
418    if (sscanf(line, EXPORT_FOREACH_STR "%zu", &forEachCount) != 1) {
419        ALOGE("Invalid export forEach count!: %s", line);
420        goto error;
421    }
422
423    forEachFunctions = new ForEachFunc_t[forEachCount];
424    if (forEachFunctions == nullptr) {
425        goto error;
426    }
427
428    forEachSignatures = new uint32_t[forEachCount];
429    if (forEachSignatures == nullptr) {
430        goto error;
431    }
432
433    for (size_t i = 0; i < forEachCount; ++i) {
434        unsigned int tmpSig = 0;
435        char tmpName[MAXLINE];
436
437        if (strgets(line, MAXLINE, &rsInfo) == nullptr) {
438            goto error;
439        }
440        if (sscanf(line, "%u - %" MAKE_STR(MAXLINE) "s",
441                   &tmpSig, tmpName) != 2) {
442          ALOGE("Invalid export forEach!: %s", line);
443          goto error;
444        }
445
446        // Lookup the expanded ForEach kernel.
447        strncat(tmpName, ".expand", MAXLINE-1-strlen(tmpName));
448        forEachSignatures[i] = tmpSig;
449        forEachFunctions[i] =
450            (ForEachFunc_t) dlsym(sharedObj, tmpName);
451        if (i != 0 && forEachFunctions[i] == nullptr &&
452            strcmp(tmpName, "root.expand")) {
453            // Ignore missing root.expand functions.
454            // root() is always specified at location 0.
455            ALOGE("Failed to find forEach function address for %s: %s",
456                  tmpName, dlerror());
457            goto error;
458        }
459    }
460
461    if (strgets(line, MAXLINE, &rsInfo) == nullptr) {
462        goto error;
463    }
464    if (sscanf(line, OBJECT_SLOT_STR "%zu", &objectSlotCount) != 1) {
465        ALOGE("Invalid object slot count!: %s", line);
466        goto error;
467    }
468
469    for (size_t i = 0; i < objectSlotCount; ++i) {
470        uint32_t varNum = 0;
471        if (strgets(line, MAXLINE, &rsInfo) == nullptr) {
472            goto error;
473        }
474        if (sscanf(line, "%u", &varNum) != 1) {
475            ALOGE("Invalid object slot!: %s", line);
476            goto error;
477        }
478
479        if (varNum < varCount) {
480            fieldIsObject[varNum] = true;
481        }
482    }
483
484#ifndef RS_COMPATIBILITY_LIB
485    // Do not attempt to read pragmas or isThreadable flag in compat lib path.
486    // Neither is applicable for compat lib
487
488    if (strgets(line, MAXLINE, &rsInfo) == nullptr) {
489        goto error;
490    }
491
492    if (sscanf(line, PRAGMA_STR "%zu", &pragmaCount) != 1) {
493        ALOGE("Invalid pragma count!: %s", line);
494        goto error;
495    }
496
497    pragmaKeys = new const char*[pragmaCount];
498    if (pragmaKeys == nullptr) {
499        goto error;
500    }
501
502    pragmaValues = new const char*[pragmaCount];
503    if (pragmaValues == nullptr) {
504        goto error;
505    }
506
507    bzero(pragmaKeys, sizeof(char*) * pragmaCount);
508    bzero(pragmaValues, sizeof(char*) * pragmaCount);
509
510    for (size_t i = 0; i < pragmaCount; ++i) {
511        if (strgets(line, MAXLINE, &rsInfo) == nullptr) {
512            ALOGE("Unable to read pragma at index %zu!", i);
513            goto error;
514        }
515        char key[MAXLINE];
516        char value[MAXLINE] = ""; // initialize in case value is empty
517
518        // pragmas can just have a key and no value.  Only check to make sure
519        // that the key is not empty
520        if (sscanf(line, "%" MAKE_STR(MAXLINE) "s - %" MAKE_STR(MAXLINE) "s",
521                   key, value) == 0 ||
522            strlen(key) == 0)
523        {
524            ALOGE("Invalid pragma value!: %s", line);
525
526            goto error;
527        }
528
529        char *pKey = new char[strlen(key)+1];
530        strcpy(pKey, key);
531        pragmaKeys[i] = pKey;
532
533        char *pValue = new char[strlen(value)+1];
534        strcpy(pValue, value);
535        pragmaValues[i] = pValue;
536        //ALOGE("Pragma %zu: Key: '%s' Value: '%s'", i, pKey, pValue);
537    }
538
539    if (strgets(line, MAXLINE, &rsInfo) == nullptr) {
540        goto error;
541    }
542
543    char tmpFlag[4];
544    if (sscanf(line, THREADABLE_STR "%4s", tmpFlag) != 1) {
545        ALOGE("Invalid threadable flag!: %s", line);
546        goto error;
547    }
548    if (strcmp(tmpFlag, "yes") == 0) {
549        isThreadable = true;
550    } else if (strcmp(tmpFlag, "no") == 0) {
551        isThreadable = false;
552    } else {
553        ALOGE("Invalid threadable flag!: %s", tmpFlag);
554        goto error;
555    }
556
557    if (strgets(line, MAXLINE, &rsInfo) != nullptr) {
558        if (strncmp(line, CHECKSUM_STR, strlen(CHECKSUM_STR)) != 0) {
559            ALOGE("Invalid checksum flag!: %s", line);
560            goto error;
561        }
562
563        // consume trailing newline character
564        char *c = strrchr(line, '\n');
565        if (c) {
566            *c = '\0';
567        }
568
569        char *checksumStart = &line[strlen(CHECKSUM_STR)];
570        checksum = new char[strlen(checksumStart) + 1];
571        strcpy(checksum, checksumStart);
572    } else {
573        ALOGE("Missing checksum in shared obj file");
574        goto error;
575    }
576
577#endif  // RS_COMPATIBILITY_LIB
578
579    return new ScriptExecutable(
580        RSContext, fieldAddress, fieldIsObject, fieldName, varCount,
581        invokeFunctions, funcCount,
582        forEachFunctions, forEachSignatures, forEachCount,
583        pragmaKeys, pragmaValues, pragmaCount,
584        isThreadable, checksum);
585
586error:
587
588#ifndef RS_COMPATIBILITY_LIB
589    delete[] checksum;
590
591    for (size_t idx = 0; idx < pragmaCount; ++idx) {
592        delete [] pragmaKeys[idx];
593        delete [] pragmaValues[idx];
594    }
595
596    delete[] pragmaValues;
597    delete[] pragmaKeys;
598#endif  // RS_COMPATIBILITY_LIB
599
600    delete[] forEachSignatures;
601    delete[] forEachFunctions;
602
603    delete[] invokeFunctions;
604
605    for (size_t i = 0; i < varCount; i++) {
606        delete[] fieldName[i];
607    }
608    delete[] fieldName;
609    delete[] fieldIsObject;
610    delete[] fieldAddress;
611
612    return nullptr;
613}
614
615void* ScriptExecutable::getFieldAddress(const char* name) const {
616    // TODO: improve this by using a hash map.
617    for (size_t i = 0; i < mExportedVarCount; i++) {
618        if (strcmp(name, mFieldName[i]) == 0) {
619            return mFieldAddress[i];
620        }
621    }
622    return nullptr;
623}
624
625}  // namespace renderscript
626}  // namespace android
627