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