vm/Native.cpp

   1 /*
   2  * Copyright (C) 2008 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 /*
  18  * Native method resolution.
  19  *
  20  * Currently the "Dalvik native" methods are only used for internal methods.
  21  * Someday we may want to export the interface as a faster but riskier
  22  * alternative to JNI.
  23  */
  24 #include "Dalvik.h"
  25
  26 #include <stdlib.h>
  27 #include <dlfcn.h>
  28
  29 static void freeSharedLibEntry(void* ptr);
  30 static void* lookupSharedLibMethod(const Method* method);
  31
  32
  33 /*
  34  * Initialize the native code loader.
  35  */
  36 bool dvmNativeStartup()
  37 {
  38     gDvm.nativeLibs = dvmHashTableCreate(4, freeSharedLibEntry);
  39     if (gDvm.nativeLibs == NULL)
  40         return false;
  41
  42     return true;
  43 }
  44
  45 /*
  46  * Free up our tables.
  47  */
  48 void dvmNativeShutdown()
  49 {
  50     dvmHashTableFree(gDvm.nativeLibs);
  51     gDvm.nativeLibs = NULL;
  52 }
  53
  54
  55 /*
  56  * Resolve a native method and invoke it.
  57  *
  58  * This is executed as if it were a native bridge or function.  If the
  59  * resolution succeeds, method->insns is replaced, and we don't go through
  60  * here again unless the method is unregistered.
  61  *
  62  * Initializes method's class if necessary.
  63  *
  64  * An exception is thrown on resolution failure.
  65  *
  66  * (This should not be taking "const Method*", because it modifies the
  67  * structure, but the declaration needs to match the DalvikBridgeFunc
  68  * type definition.)
  69  */
  70 void dvmResolveNativeMethod(const u4* args, JValue* pResult,
  71     const Method* method, Thread* self)
  72 {
  73     ClassObject* clazz = method->clazz;
  74
  75     /*
  76      * If this is a static method, it could be called before the class
  77      * has been initialized.
  78      */
  79     if (dvmIsStaticMethod(method)) {
  80         if (!dvmIsClassInitialized(clazz) && !dvmInitClass(clazz)) {
  81             assert(dvmCheckException(dvmThreadSelf()));
  82             return;
  83         }
  84     } else {
  85         assert(dvmIsClassInitialized(clazz) ||
  86                dvmIsClassInitializing(clazz));
  87     }
  88
  89     /* start with our internal-native methods */
  90     DalvikNativeFunc infunc = dvmLookupInternalNativeMethod(method);
  91     if (infunc != NULL) {
  92         /* resolution always gets the same answer, so no race here */
  93         IF_LOGVV() {
  94             char* desc = dexProtoCopyMethodDescriptor(&method->prototype);
  95             LOGVV("+++ resolved native %s.%s %s, invoking",
  96                 clazz->descriptor, method->name, desc);
  97             free(desc);
  98         }
  99         if (dvmIsSynchronizedMethod(method)) {
 100             ALOGE("ERROR: internal-native can't be declared 'synchronized'");
 101             ALOGE("Failing on %s.%s", method->clazz->descriptor, method->name);
 102             dvmAbort();     // harsh, but this is VM-internal problem
 103         }
 104         DalvikBridgeFunc dfunc = (DalvikBridgeFunc) infunc;
 105         dvmSetNativeFunc((Method*) method, dfunc, NULL);
 106         dfunc(args, pResult, method, self);
 107         return;
 108     }
 109
 110     /* now scan any DLLs we have loaded for JNI signatures */
 111     void* func = lookupSharedLibMethod(method);
 112     if (func != NULL) {
 113         /* found it, point it at the JNI bridge and then call it */
 114         dvmUseJNIBridge((Method*) method, func);
 115         (*method->nativeFunc)(args, pResult, method, self);
 116         return;
 117     }
 118
 119     IF_ALOGW() {
 120         char* desc = dexProtoCopyMethodDescriptor(&method->prototype);
 121         ALOGW("No implementation found for native %s.%s:%s",
 122             clazz->descriptor, method->name, desc);
 123         free(desc);
 124     }
 125
 126     dvmThrowUnsatisfiedLinkError("Native method not found", method);
 127 }
 128
 129
 130 /*
 131  * ===========================================================================
 132  *      Native shared library support
 133  * ===========================================================================
 134  */
 135
 136 // TODO? if a ClassLoader is unloaded, we need to unload all DLLs that
 137 // are associated with it.  (Or not -- can't determine if native code
 138 // is still using parts of it.)
 139
 140 enum OnLoadState {
 141     kOnLoadPending = 0,     /* initial state, must be zero */
 142     kOnLoadFailed,
 143     kOnLoadOkay,
 144 };
 145
 146 /*
 147  * We add one of these to the hash table for every library we load.  The
 148  * hash is on the "pathName" field.
 149  */
 150 struct SharedLib {
 151     char*       pathName;           /* absolute path to library */
 152     void*       handle;             /* from dlopen */
 153     Object*     classLoader;        /* ClassLoader we are associated with */
 154
 155     pthread_mutex_t onLoadLock;     /* guards remaining items */
 156     pthread_cond_t  onLoadCond;     /* wait for JNI_OnLoad in other thread */
 157     u4              onLoadThreadId; /* recursive invocation guard */
 158     OnLoadState     onLoadResult;   /* result of earlier JNI_OnLoad */
 159 };
 160
 161 /*
 162  * (This is a dvmHashTableLookup callback.)
 163  *
 164  * Find an entry that matches the string.
 165  */
 166 static int hashcmpNameStr(const void* ventry, const void* vname)
 167 {
 168     const SharedLib* pLib = (const SharedLib*) ventry;
 169     const char* name = (const char*) vname;
 170
 171     return strcmp(pLib->pathName, name);
 172 }
 173
 174 /*
 175  * (This is a dvmHashTableLookup callback.)
 176  *
 177  * Find an entry that matches the new entry.
 178  *
 179  * We don't compare the class loader here, because you're not allowed to
 180  * have the same shared library associated with more than one CL.
 181  */
 182 static int hashcmpSharedLib(const void* ventry, const void* vnewEntry)
 183 {
 184     const SharedLib* pLib = (const SharedLib*) ventry;
 185     const SharedLib* pNewLib = (const SharedLib*) vnewEntry;
 186
 187     ALOGD("--- comparing %p '%s' %p '%s'",
 188         pLib, pLib->pathName, pNewLib, pNewLib->pathName);
 189     return strcmp(pLib->pathName, pNewLib->pathName);
 190 }
 191
 192 /*
 193  * Check to see if an entry with the same pathname already exists.
 194  */
 195 static SharedLib* findSharedLibEntry(const char* pathName)
 196 {
 197     u4 hash = dvmComputeUtf8Hash(pathName);
 198     void* ent;
 199
 200     ent = dvmHashTableLookup(gDvm.nativeLibs, hash, (void*)pathName,
 201                 hashcmpNameStr, false);
 202     return (SharedLib*)ent;
 203 }
 204
 205 /*
 206  * Add the new entry to the table.
 207  *
 208  * Returns the table entry, which will not be the same as "pLib" if the
 209  * entry already exists.
 210  */
 211 static SharedLib* addSharedLibEntry(SharedLib* pLib)
 212 {
 213     u4 hash = dvmComputeUtf8Hash(pLib->pathName);
 214
 215     /*
 216      * Do the lookup with the "add" flag set.  If we add it, we will get
 217      * our own pointer back.  If somebody beat us to the punch, we'll get
 218      * their pointer back instead.
 219      */
 220     return (SharedLib*)dvmHashTableLookup(gDvm.nativeLibs, hash, pLib,
 221                 hashcmpSharedLib, true);
 222 }
 223
 224 /*
 225  * Free up an entry.  (This is a dvmHashTableFree callback.)
 226  */
 227 static void freeSharedLibEntry(void* ptr)
 228 {
 229     SharedLib* pLib = (SharedLib*) ptr;
 230
 231     /*
 232      * Calling dlclose() here is somewhat dangerous, because it's possible
 233      * that a thread outside the VM is still accessing the code we loaded.
 234      */
 235     if (false)
 236         dlclose(pLib->handle);
 237     free(pLib->pathName);
 238     free(pLib);
 239 }
 240
 241 /*
 242  * Convert library name to system-dependent form, e.g. "jpeg" becomes
 243  * "libjpeg.so".
 244  *
 245  * (Should we have this take buffer+len and avoid the alloc?  It gets
 246  * called very rarely.)
 247  */
 248 char* dvmCreateSystemLibraryName(char* libName)
 249 {
 250     char buf[256];
 251     int len;
 252
 253     len = snprintf(buf, sizeof(buf), OS_SHARED_LIB_FORMAT_STR, libName);
 254     if (len >= (int) sizeof(buf))
 255         return NULL;
 256     else
 257         return strdup(buf);
 258 }
 259
 260 /*
 261  * Check the result of an earlier call to JNI_OnLoad on this library.  If
 262  * the call has not yet finished in another thread, wait for it.
 263  */
 264 static bool checkOnLoadResult(SharedLib* pEntry)
 265 {
 266     Thread* self = dvmThreadSelf();
 267     if (pEntry->onLoadThreadId == self->threadId) {
 268         /*
 269          * Check this so we don't end up waiting for ourselves.  We need
 270          * to return "true" so the caller can continue.
 271          */
 272         ALOGI("threadid=%d: recursive native library load attempt (%s)",
 273             self->threadId, pEntry->pathName);
 274         return true;
 275     }
 276
 277     ALOGV("+++ retrieving %s OnLoad status", pEntry->pathName);
 278     bool result;
 279
 280     dvmLockMutex(&pEntry->onLoadLock);
 281     while (pEntry->onLoadResult == kOnLoadPending) {
 282         ALOGD("threadid=%d: waiting for %s OnLoad status",
 283             self->threadId, pEntry->pathName);
 284         ThreadStatus oldStatus = dvmChangeStatus(self, THREAD_VMWAIT);
 285         pthread_cond_wait(&pEntry->onLoadCond, &pEntry->onLoadLock);
 286         dvmChangeStatus(self, oldStatus);
 287     }
 288     if (pEntry->onLoadResult == kOnLoadOkay) {
 289         ALOGV("+++ earlier OnLoad(%s) okay", pEntry->pathName);
 290         result = true;
 291     } else {
 292         ALOGV("+++ earlier OnLoad(%s) failed", pEntry->pathName);
 293         result = false;
 294     }
 295     dvmUnlockMutex(&pEntry->onLoadLock);
 296     return result;
 297 }
 298
 299 typedef int (*OnLoadFunc)(JavaVM*, void*);
 300
 301 /*
 302  * Load native code from the specified absolute pathname.  Per the spec,
 303  * if we've already loaded a library with the specified pathname, we
 304  * return without doing anything.
 305  *
 306  * TODO? for better results we should absolutify the pathname.  For fully
 307  * correct results we should stat to get the inode and compare that.  The
 308  * existing implementation is fine so long as everybody is using
 309  * System.loadLibrary.
 310  *
 311  * The library will be associated with the specified class loader.  The JNI
 312  * spec says we can't load the same library into more than one class loader.
 313  *
 314  * Returns "true" on success. On failure, sets *detail to a
 315  * human-readable description of the error or NULL if no detail is
 316  * available; ownership of the string is transferred to the caller.
 317  */
 318 bool dvmLoadNativeCode(const char* pathName, Object* classLoader,
 319         char** detail)
 320 {
 321     SharedLib* pEntry;
 322     void* handle;
 323     bool verbose;
 324
 325     /* reduce noise by not chattering about system libraries */
 326     verbose = !!strncmp(pathName, "/system", sizeof("/system")-1);
 327     verbose = verbose && !!strncmp(pathName, "/vendor", sizeof("/vendor")-1);
 328
 329     if (verbose)
 330         ALOGD("Trying to load lib %s %p", pathName, classLoader);
 331
 332     *detail = NULL;
 333
 334     /*
 335      * See if we've already loaded it.  If we have, and the class loader
 336      * matches, return successfully without doing anything.
 337      */
 338     pEntry = findSharedLibEntry(pathName);
 339     if (pEntry != NULL) {
 340         if (pEntry->classLoader != classLoader) {
 341             ALOGW("Shared lib '%s' already opened by CL %p; can't open in %p",
 342                 pathName, pEntry->classLoader, classLoader);
 343             return false;
 344         }
 345         if (verbose) {
 346             ALOGD("Shared lib '%s' already loaded in same CL %p",
 347                 pathName, classLoader);
 348         }
 349         if (!checkOnLoadResult(pEntry))
 350             return false;
 351         return true;
 352     }
 353
 354     /*
 355      * Open the shared library.  Because we're using a full path, the system
 356      * doesn't have to search through LD_LIBRARY_PATH.  (It may do so to
 357      * resolve this library's dependencies though.)
 358      *
 359      * Failures here are expected when java.library.path has several entries
 360      * and we have to hunt for the lib.
 361      *
 362      * The current version of the dynamic linker prints detailed information
 363      * about dlopen() failures.  Some things to check if the message is
 364      * cryptic:
 365      *   - make sure the library exists on the device
 366      *   - verify that the right path is being opened (the debug log message
 367      *     above can help with that)
 368      *   - check to see if the library is valid (e.g. not zero bytes long)
 369      *   - check config/prelink-linux-arm.map to ensure that the library
 370      *     is listed and is not being overrun by the previous entry (if
 371      *     loading suddenly stops working on a prelinked library, this is
 372      *     a good one to check)
 373      *   - write a trivial app that calls sleep() then dlopen(), attach
 374      *     to it with "strace -p <pid>" while it sleeps, and watch for
 375      *     attempts to open nonexistent dependent shared libs
 376      *
 377      * This can execute slowly for a large library on a busy system, so we
 378      * want to switch from RUNNING to VMWAIT while it executes.  This allows
 379      * the GC to ignore us.
 380      */
 381     Thread* self = dvmThreadSelf();
 382     ThreadStatus oldStatus = dvmChangeStatus(self, THREAD_VMWAIT);
 383     handle = dlopen(pathName, RTLD_LAZY);
 384     dvmChangeStatus(self, oldStatus);
 385
 386     if (handle == NULL) {
 387         *detail = strdup(dlerror());
 388         ALOGE("dlopen(\"%s\") failed: %s", pathName, *detail);
 389         return false;
 390     }
 391
 392     /* create a new entry */
 393     SharedLib* pNewEntry;
 394     pNewEntry = (SharedLib*) calloc(1, sizeof(SharedLib));
 395     pNewEntry->pathName = strdup(pathName);
 396     pNewEntry->handle = handle;
 397     pNewEntry->classLoader = classLoader;
 398     dvmInitMutex(&pNewEntry->onLoadLock);
 399     pthread_cond_init(&pNewEntry->onLoadCond, NULL);
 400     pNewEntry->onLoadThreadId = self->threadId;
 401
 402     /* try to add it to the list */
 403     SharedLib* pActualEntry = addSharedLibEntry(pNewEntry);
 404
 405     if (pNewEntry != pActualEntry) {
 406         ALOGI("WOW: we lost a race to add a shared lib (%s CL=%p)",
 407             pathName, classLoader);
 408         freeSharedLibEntry(pNewEntry);
 409         return checkOnLoadResult(pActualEntry);
 410     } else {
 411         if (verbose)
 412             ALOGD("Added shared lib %s %p", pathName, classLoader);
 413
 414         bool result = true;
 415         void* vonLoad;
 416         int version;
 417
 418         vonLoad = dlsym(handle, "JNI_OnLoad");
 419         if (vonLoad == NULL) {
 420             ALOGD("No JNI_OnLoad found in %s %p, skipping init",
 421                 pathName, classLoader);
 422         } else {
 423             /*
 424              * Call JNI_OnLoad.  We have to override the current class
 425              * loader, which will always be "null" since the stuff at the
 426              * top of the stack is around Runtime.loadLibrary().  (See
 427              * the comments in the JNI FindClass function.)
 428              */
 429             OnLoadFunc func = (OnLoadFunc)vonLoad;
 430             Object* prevOverride = self->classLoaderOverride;
 431
 432             self->classLoaderOverride = classLoader;
 433             oldStatus = dvmChangeStatus(self, THREAD_NATIVE);
 434             if (gDvm.verboseJni) {
 435                 ALOGI("[Calling JNI_OnLoad for \"%s\"]", pathName);
 436             }
 437             version = (*func)(gDvmJni.jniVm, NULL);
 438             dvmChangeStatus(self, oldStatus);
 439             self->classLoaderOverride = prevOverride;
 440
 441             if (version != JNI_VERSION_1_2 && version != JNI_VERSION_1_4 &&
 442                 version != JNI_VERSION_1_6)
 443             {
 444                 ALOGW("JNI_OnLoad returned bad version (%d) in %s %p",
 445                     version, pathName, classLoader);
 446                 /*
 447                  * It's unwise to call dlclose() here, but we can mark it
 448                  * as bad and ensure that future load attempts will fail.
 449                  *
 450                  * We don't know how far JNI_OnLoad got, so there could
 451                  * be some partially-initialized stuff accessible through
 452                  * newly-registered native method calls.  We could try to
 453                  * unregister them, but that doesn't seem worthwhile.
 454                  */
 455                 result = false;
 456             } else {
 457                 if (gDvm.verboseJni) {
 458                     ALOGI("[Returned from JNI_OnLoad for \"%s\"]", pathName);
 459                 }
 460             }
 461         }
 462
 463         if (result)
 464             pNewEntry->onLoadResult = kOnLoadOkay;
 465         else
 466             pNewEntry->onLoadResult = kOnLoadFailed;
 467
 468         pNewEntry->onLoadThreadId = 0;
 469
 470         /*
 471          * Broadcast a wakeup to anybody sleeping on the condition variable.
 472          */
 473         dvmLockMutex(&pNewEntry->onLoadLock);
 474         pthread_cond_broadcast(&pNewEntry->onLoadCond);
 475         dvmUnlockMutex(&pNewEntry->onLoadLock);
 476         return result;
 477     }
 478 }
 479
 480
 481 /*
 482  * Un-register JNI native methods.
 483  *
 484  * There are two relevant fields in struct Method, "nativeFunc" and
 485  * "insns".  The former holds a function pointer to a "bridge" function
 486  * (or, for internal native, the actual implementation).  The latter holds
 487  * a pointer to the actual JNI method.
 488  *
 489  * The obvious approach is to reset both fields to their initial state
 490  * (nativeFunc points at dvmResolveNativeMethod, insns holds NULL), but
 491  * that creates some unpleasant race conditions.  In particular, if another
 492  * thread is executing inside the call bridge for the method in question,
 493  * and we reset insns to NULL, the VM will crash.  (See the comments above
 494  * dvmSetNativeFunc() for additional commentary.)
 495  *
 496  * We can't rely on being able to update two 32-bit fields in one atomic
 497  * operation (e.g. no 64-bit atomic ops on ARMv5TE), so we want to change
 498  * only one field.  It turns out we can simply reset nativeFunc to its
 499  * initial state, leaving insns alone, because dvmResolveNativeMethod
 500  * ignores "insns" entirely.
 501  *
 502  * When the method is re-registered, both fields will be updated, but
 503  * dvmSetNativeFunc guarantees that "insns" is updated first.  This means
 504  * we shouldn't be in a situation where we have a "live" call bridge and
 505  * a stale implementation pointer.
 506  */
 507 static void unregisterJNINativeMethods(Method* methods, size_t count)
 508 {
 509     while (count != 0) {
 510         count--;
 511
 512         Method* meth = &methods[count];
 513         if (!dvmIsNativeMethod(meth))
 514             continue;
 515         if (dvmIsAbstractMethod(meth))      /* avoid abstract method stubs */
 516             continue;
 517
 518         /*
 519          * Strictly speaking this ought to test the function pointer against
 520          * the various JNI bridge functions to ensure that we only undo
 521          * methods that were registered through JNI.  In practice, any
 522          * native method with a non-NULL "insns" is a registered JNI method.
 523          *
 524          * If we inadvertently unregister an internal-native, it'll get
 525          * re-resolved on the next call; unregistering an unregistered
 526          * JNI method is a no-op.  So we don't really need to test for
 527          * anything.
 528          */
 529
 530         ALOGD("Unregistering JNI method %s.%s:%s",
 531             meth->clazz->descriptor, meth->name, meth->shorty);
 532         dvmSetNativeFunc(meth, dvmResolveNativeMethod, NULL);
 533     }
 534 }
 535
 536 /*
 537  * Un-register all JNI native methods from a class.
 538  */
 539 void dvmUnregisterJNINativeMethods(ClassObject* clazz)
 540 {
 541     unregisterJNINativeMethods(clazz->directMethods, clazz->directMethodCount);
 542     unregisterJNINativeMethods(clazz->virtualMethods, clazz->virtualMethodCount);
 543 }
 544
 545
 546 /*
 547  * ===========================================================================
 548  *      Signature-based method lookup
 549  * ===========================================================================
 550  */
 551
 552 /*
 553  * Create the pre-mangled form of the class+method string.
 554  *
 555  * Returns a newly-allocated string, and sets "*pLen" to the length.
 556  */
 557 static char* createJniNameString(const char* classDescriptor,
 558     const char* methodName, int* pLen)
 559 {
 560     char* result;
 561     size_t descriptorLength = strlen(classDescriptor);
 562
 563     *pLen = 4 + descriptorLength + strlen(methodName);
 564
 565     result = (char*)malloc(*pLen +1);
 566     if (result == NULL)
 567         return NULL;
 568
 569     /*
 570      * Add one to classDescriptor to skip the "L", and then replace
 571      * the final ";" with a "/" after the sprintf() call.
 572      */
 573     sprintf(result, "Java/%s%s", classDescriptor + 1, methodName);
 574     result[5 + (descriptorLength - 2)] = '/';
 575
 576     return result;
 577 }
 578
 579 /*
 580  * Returns a newly-allocated, mangled copy of "str".
 581  *
 582  * "str" is a "modified UTF-8" string.  We convert it to UTF-16 first to
 583  * make life simpler.
 584  */
 585 static char* mangleString(const char* str, int len)
 586 {
 587     //ALOGI("mangling '%s' %d", str, len);
 588
 589     assert(str[len] == '\0');
 590
 591     size_t charLen = dvmUtf8Len(str);
 592     u2* utf16 = (u2*) malloc(sizeof(u2) * charLen);
 593     if (utf16 == NULL)
 594         return NULL;
 595
 596     dvmConvertUtf8ToUtf16(utf16, str);
 597
 598     /*
 599      * Compute the length of the mangled string.
 600      */
 601     size_t mangleLen = 0;
 602     for (size_t i = 0; i < charLen; i++) {
 603         u2 ch = utf16[i];
 604
 605         if (ch == '$' || ch > 127) {
 606             mangleLen += 6;
 607         } else {
 608             switch (ch) {
 609             case '_':
 610             case ';':
 611             case '[':
 612                 mangleLen += 2;
 613                 break;
 614             default:
 615                 mangleLen++;
 616                 break;
 617             }
 618         }
 619     }
 620
 621     char* mangle = (char*) malloc(mangleLen +1);
 622     if (mangle == NULL) {
 623         free(utf16);
 624         return NULL;
 625     }
 626
 627     char* cp = mangle;
 628     for (size_t i = 0; i < charLen; i++) {
 629         u2 ch = utf16[i];
 630
 631         if (ch == '$' || ch > 127) {
 632             sprintf(cp, "_0%04x", ch);
 633             cp += 6;
 634         } else {
 635             switch (ch) {
 636             case '_':
 637                 *cp++ = '_';
 638                 *cp++ = '1';
 639                 break;
 640             case ';':
 641                 *cp++ = '_';
 642                 *cp++ = '2';
 643                 break;
 644             case '[':
 645                 *cp++ = '_';
 646                 *cp++ = '3';
 647                 break;
 648             case '/':
 649                 *cp++ = '_';
 650                 break;
 651             default:
 652                 *cp++ = (char) ch;
 653                 break;
 654             }
 655         }
 656     }
 657
 658     *cp = '\0';
 659
 660     free(utf16);
 661     return mangle;
 662 }
 663
 664 /*
 665  * Create the mangled form of the parameter types.
 666  */
 667 static char* createMangledSignature(const DexProto* proto)
 668 {
 669     DexStringCache sigCache;
 670     const char* interim;
 671     char* result;
 672
 673     dexStringCacheInit(&sigCache);
 674     interim = dexProtoGetParameterDescriptors(proto, &sigCache);
 675     result = mangleString(interim, strlen(interim));
 676     dexStringCacheRelease(&sigCache);
 677
 678     return result;
 679 }
 680
 681 /*
 682  * (This is a dvmHashForeach callback.)
 683  *
 684  * Search for a matching method in this shared library.
 685  *
 686  * TODO: we may want to skip libraries for which JNI_OnLoad failed.
 687  */
 688 static int findMethodInLib(void* vlib, void* vmethod)
 689 {
 690     const SharedLib* pLib = (const SharedLib*) vlib;
 691     const Method* meth = (const Method*) vmethod;
 692     char* preMangleCM = NULL;
 693     char* mangleCM = NULL;
 694     char* mangleSig = NULL;
 695     char* mangleCMSig = NULL;
 696     void* func = NULL;
 697     int len;
 698
 699     if (meth->clazz->classLoader != pLib->classLoader) {
 700         ALOGV("+++ not scanning '%s' for '%s' (wrong CL)",
 701             pLib->pathName, meth->name);
 702         return 0;
 703     } else
 704         ALOGV("+++ scanning '%s' for '%s'", pLib->pathName, meth->name);
 705
 706     /*
 707      * First, we try it without the signature.
 708      */
 709     preMangleCM =
 710         createJniNameString(meth->clazz->descriptor, meth->name, &len);
 711     if (preMangleCM == NULL)
 712         goto bail;
 713
 714     mangleCM = mangleString(preMangleCM, len);
 715     if (mangleCM == NULL)
 716         goto bail;
 717
 718     ALOGV("+++ calling dlsym(%s)", mangleCM);
 719     func = dlsym(pLib->handle, mangleCM);
 720     if (func == NULL) {
 721         mangleSig =
 722             createMangledSignature(&meth->prototype);
 723         if (mangleSig == NULL)
 724             goto bail;
 725
 726         mangleCMSig = (char*) malloc(strlen(mangleCM) + strlen(mangleSig) +3);
 727         if (mangleCMSig == NULL)
 728             goto bail;
 729
 730         sprintf(mangleCMSig, "%s__%s", mangleCM, mangleSig);
 731
 732         ALOGV("+++ calling dlsym(%s)", mangleCMSig);
 733         func = dlsym(pLib->handle, mangleCMSig);
 734         if (func != NULL) {
 735             ALOGV("Found '%s' with dlsym", mangleCMSig);
 736         }
 737     } else {
 738         ALOGV("Found '%s' with dlsym", mangleCM);
 739     }
 740
 741 bail:
 742     free(preMangleCM);
 743     free(mangleCM);
 744     free(mangleSig);
 745     free(mangleCMSig);
 746     return (int) func;
 747 }
 748
 749 /*
 750  * See if the requested method lives in any of the currently-loaded
 751  * shared libraries.  We do this by checking each of them for the expected
 752  * method signature.
 753  */
 754 static void* lookupSharedLibMethod(const Method* method)
 755 {
 756     if (gDvm.nativeLibs == NULL) {
 757         ALOGE("Unexpected init state: nativeLibs not ready");
 758         dvmAbort();
 759     }
 760     return (void*) dvmHashForeach(gDvm.nativeLibs, findMethodInLib,
 761         (void*) method);
 762 }