Android中的类加载-查找和在hotpatch上的问题

1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51

private static Element[]   makeDexElements(ArrayList<File> files,
                                             File optimizedDirectory) {
      ArrayList<Element> elements =   new ArrayList<Element>();
      /*
       * Open all files and load the   (direct or contained) dex files
       * up front.
       */
      for (File file : files) {
          ZipFile zip = null;
          DexFile dex = null;
          String name = file.getName();
          if (name.endsWith(DEX_SUFFIX)) {
              // Raw dex file (not inside a zip/jar).
              try {
                  dex = loadDexFile(file,   optimizedDirectory);
              } catch (IOException ex) {
                  System.logE("Unable to load dex file: " + file, ex);
              }
          } else if (name.endsWith(APK_SUFFIX) ||   name.endsWith(JAR_SUFFIX)
                  ||   name.endsWith(ZIP_SUFFIX)) {
              try {
                  zip = new ZipFile(file);
              } catch (IOException ex) {
                  /*
                   * Note: ZipException   (a subclass of IOException)
                   * might get thrown by   the ZipFile constructor
                   * (e.g. if the file   isn't actually a zip/jar
                   * file).
                   */
                  System.logE("Unable to open zip file: " + file, ex);
              }
              try {
                  dex = loadDexFile(file,   optimizedDirectory);
              } catch (IOException ignored) {
                  /*
                   * IOException might   get thrown "legitimately" by
                   * the DexFile   constructor if the zip file turns
                   * out to be resource-only (that is, no
                   * classes.dex file in   it). Safe to just ignore
                   * the exception here,   and let dex == null.
                   */
              }
          } else {
              System.logW("Unknown file type for: " + file);
          }
          if ((zip != null) || (dex != null)) {
              elements.add(new Element(file, zip, dex));
          }
      }
      return elements.toArray(new Element[elements.size()]);
  }

1
  2
  3
  4
  5
  6
  7
  8
  9

private static DexFile loadDexFile(File file, File optimizedDirectory)
          throws IOException {
      if (optimizedDirectory == null) {
          return new DexFile(file);
      } else {
          String optimizedPath =   optimizedPathFor(file, optimizedDirectory);
          return DexFile.loadDex(file.getPath(),   optimizedPath, 0);
      }
  }

1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38

static jlong DexFile_openDexFileNative(JNIEnv* env, jclass, jstring   javaSourceName, jstring javaOutputName, jint) {
      ScopedUtfChars sourceName(env, javaSourceName);
      if (sourceName.c_str() == NULL) {
          return 0;
      }
      NullableScopedUtfChars outputName(env, javaOutputName);
      if (env->ExceptionCheck()) {
          return 0;
      }
 
      ClassLinker* linker =   Runtime::Current()->GetClassLinker();
      std::unique_ptr<std::vector<const DexFile*>> dex_files(new std::vector<const DexFile*>());
      std::vector<std::string> error_msgs;
 
      bool success =   linker->OpenDexFilesFromOat(sourceName.c_str(), outputName.c_str(),   &error_msgs,
      dex_files.get());
 
      if (success || !dex_files->empty()) {
          // In the case of non-success, we have   not found or could not generate the oat file.
          // But we may still have found a dex file   that we can use.
          return static_cast<jlong>(reinterpret_cast<uintptr_t>(dex_files.release()));
      } else {
          // The vector should be empty after a   failed loading attempt.
          DCHECK_EQ(0U, dex_files->size());
 
          ScopedObjectAccess soa(env);
          CHECK(!error_msgs.empty());
          // The most important message is at the   end. So set up nesting by going forward, which will
          // wrap the existing exception as a cause   for the following one.
          auto it = error_msgs.begin();
          auto itEnd = error_msgs.end();
          for ( ; it != itEnd; ++it) {
              ThrowWrappedIOException("%s", it->c_str());
          }
 
          return 0;
      }
  }

1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36
  37
  38
  39
  40
  41
  42
  43
  44
  45
  46
  47
  48
  49
  50
  51
  52
  53
  54
  55
  56
  57
  58
  59
  60
  61
  62
  63
  64
  65
  66
  67
  68
  69
  70
  71
  72
  73
  74
  75
  76
  77
  78
  79
  80
  81
  82
  83
  84
  85
  86
  87
  88
  89
  90
  91
  92
  93
  94
  95
  96
  97
  98
  99
  100
  101
  102
  103
  104
  105
  106
  107
  108
  109
  110
  111
  112
  113
  114
  115
  116
  117
  118
  119
  120
  121
  122
  123
  124
  125
  126
  127
  128
  129
  130
  131
  132
  133
  134
  135
  136
  137
  138
  139
  140
  141

bool   ClassLinker::OpenDexFilesFromOat(const char* dex_location, const char* oat_location,std::vector<std::string>*   error_msgs,std::vector<const DexFile*>*   dex_files) {
      // 1) Check whether we have an open oat   file.
      // This requires a dex checksum, use the   "primary" one.
      uint32_t dex_location_checksum;
      uint32_t*   dex_location_checksum_pointer = &dex_location_checksum;
      bool have_checksum = true;
      std::string checksum_error_msg;
      if (!DexFile::GetChecksum(dex_location,   dex_location_checksum_pointer, &checksum_error_msg)) {
          // This happens for pre-opted files since   the corresponding dex files are no longer on disk.
          dex_location_checksum_pointer =   nullptr;
          have_checksum = false;
      }
 
      bool needs_registering = false;
 
      const OatFile::OatDexFile* oat_dex_file =   FindOpenedOatDexFile(oat_location, dex_location,
      dex_location_checksum_pointer);
      std::unique_ptr<const OatFile> open_oat_file(
      oat_dex_file != nullptr ?   oat_dex_file->GetOatFile() : nullptr);
 
      // 2) If we do not have an open one,   maybe there's one on disk already.
 
      // In case the oat file is not open, we   play a locking game here so
      // that if two different processes race   to load and register or generate
      // (or worse, one tries to open a partial   generated file) we will be okay.
      // This is actually common with apps that   use DexClassLoader to work
      // around the dex method reference limit   and that have a background
      // service running in a separate process.
      ScopedFlock scoped_flock;
 
      if (open_oat_file.get() == nullptr) {
           if (oat_location != nullptr) {
                    // Can only do this if we have a   checksum, else error.
                    if (!have_checksum) {
                             error_msgs->push_back(checksum_error_msg);
                             return false;
                    }
 
                             std::string   error_msg;
 
            // We are   loading or creating one in the future. Time to set up the file lock.
                    if (!scoped_flock.Init(oat_location,   &error_msg)) {
                             error_msgs->push_back(error_msg);
                             return false;
                    }
                    // TODO Caller specifically asks for   this oat_location. We should honor it. Probably?
                    open_oat_file.reset(FindOatFileInOatLocationForDexFile(dex_location,   dex_location_checksum,oat_location, &error_msg));
                    if (open_oat_file.get() == nullptr) {
                             std::string   compound_msg = StringPrintf("Failed to find dex file '%s' in oat location '%s': %s",dex_location, oat_location,   error_msg.c_str());
                             VLOG(class_linker)   << compound_msg;
                             error_msgs->push_back(compound_msg);
                    }
           }   else {
                    // TODO: What to lock here?
                    bool   obsolete_file_cleanup_failed;
         open_oat_file.reset(FindOatFileContainingDexFileFromDexLocation(dex_location,
   dex_location_checksum_pointer,kRuntimeISA,error_msgs,&obsolete_file_cleanup_failed));
                    // There's no point in going forward   and eventually try to regenerate the
                    // file if we couldn't remove the   obsolete one. Mostly likely we will fail
                    // with the same error when trying to   write the new file.
                    // TODO: should we maybe do this only   when we get permission issues? (i.e. EACCESS).
                    if (obsolete_file_cleanup_failed) {
                             return false;
                    }
           }
           needs_registering   = true;
      }
 
      // 3) If we have an oat file, check all   contained multidex files for our dex_location.
      // Note: LoadMultiDexFilesFromOatFile   will check for nullptr in the first argument.
      bool success =   LoadMultiDexFilesFromOatFile(open_oat_file.get(), dex_location,
      dex_location_checksum_pointer,false, error_msgs, dex_files);
      if (success) {
           const OatFile* oat_file = open_oat_file.release();  // Avoid deleting it.
           if (needs_registering) {
                    // We opened the oat file, so we must   register it.
                    RegisterOatFile(oat_file);
      }
           // If the file isn't executable we   failed patchoat but did manage to get the dex files.
           return oat_file->IsExecutable();
      } else {
           if (needs_registering) {
                    // We opened it, delete it.
                    open_oat_file.reset();
           }   else {
                    open_oat_file.release();  // Do not delete open oat files.
           }
      }
 
      // 4) If it's not the case (either no oat   file or mismatches), regenerate and load.
 
      // Need a checksum, fail else.
      if (!have_checksum) {
           error_msgs->push_back(checksum_error_msg);
           return false;
      }
 
      // Look in cache location if no   oat_location is given.
      std::string cache_location;
      if (oat_location == nullptr) {
           // Use the dalvik cache.
           const std::string dalvik_cache(GetDalvikCacheOrDie(GetInstructionSetString(kRuntimeISA)));
           cache_location   = GetDalvikCacheFilenameOrDie(dex_location, dalvik_cache.c_str());
           oat_location   = cache_location.c_str();
      }
 
      bool has_flock = true;
      // Definitely need to lock now.
      if (!scoped_flock.HasFile()) {
           std::string   error_msg;
           if (!scoped_flock.Init(oat_location,   &error_msg)) {
                    error_msgs->push_back(error_msg);
                    has_flock   = false;
           }
      }
 
      if   (Runtime::Current()->IsDex2OatEnabled() && has_flock &&   scoped_flock.HasFile()) {
           // Create the oat file.
           open_oat_file.reset(CreateOatFileForDexLocation(dex_location,   scoped_flock.GetFile()->Fd(),
           oat_location,   error_msgs));
      }
 
      // Failed, bail.
      if (open_oat_file.get() == nullptr) {
           std::string   error_msg;
           // dex2oat was disabled or crashed.   Add the dex file in the list of dex_files to make progress.
           DexFile::Open(dex_location,   dex_location, &error_msg, dex_files);
           error_msgs->push_back(error_msg);
           return false;
      }
 
      // Try to load again, but stronger   checks.
      success =   LoadMultiDexFilesFromOatFile(open_oat_file.get(), dex_location,
      dex_location_checksum_pointer,true, error_msgs, dex_files);
      if (success) {
           RegisterOatFile(open_oat_file.release());
           return true;
      } else {
           return false;
      }
  }

1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17

const OatFile::OatDexFile*   ClassLinker::FindOpenedOatDexFile(const char* oat_location,const char* dex_location,const uint32_t* dex_location_checksum) {
      ReaderMutexLock mu(Thread::Current(), dex_lock_);
      for (const OatFile* oat_file : oat_files_) {
           DCHECK(oat_file   != nullptr);
           if (oat_location != nullptr) {
            if (oat_file->GetLocation() !=   oat_location) {
                     continue;
                    }
          }
 
          const OatFile::OatDexFile* oat_dex_file =   oat_file->GetOatDexFile(dex_location,dex_location_checksum,false);
          if (oat_dex_file != nullptr) {
            return oat_dex_file;
          }
      }
      return nullptr;
  }

1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14

while (i < 100) {
           std::string name = StringPrintf("classes%zu.dex", i);
      std::string fake_location = location +   kMultiDexSeparator + name;
      std::unique_ptr<const DexFile>   next_dex_file(Open(zip_archive, name.c_str(), fake_location,error_msg,   &error_code));
      if (next_dex_file.get() == nullptr) {
           if (error_code != ZipOpenErrorCode::kEntryNotFound)   {
            LOG(WARNING) << error_msg;
          }
          break;
      } else {
            dex_files->push_back(next_dex_file.release());
      }
      i++;
  }

1
  2
  3
  4
  5
  6
  7
  8

@Override
  protected Class<?> findClass(String name)   throws ClassNotFoundException {
      Class clazz =   pathList.findClass(name);
      if (clazz == null) {
          throw new ClassNotFoundException(name);
      }
      return clazz;
  }

1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12

public Class findClass(String name) {
      for (Element element : dexElements) {
          DexFile dex = element.dexFile;
          if (dex != null) {
              Class clazz =   dex.loadClassBinaryName(name, definingContext);
              if (clazz != null) {
                  return clazz;
              }
          }
      }
      return null;
  }

1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34

static jclass DexFile_defineClassNative(JNIEnv* env, jclass, jstring   javaName, jobject javaLoader,
                                            jlong cookie) {
      std::vector<const DexFile*>* dex_files =   toDexFiles(cookie, env);
      if (dex_files == NULL) {
          VLOG(class_linker) << "Failed to find dex_file";
          return NULL;
      }
      ScopedUtfChars class_name(env, javaName);
      if (class_name.c_str() == NULL) {
          VLOG(class_linker) << "Failed to find class_name";
          return NULL;
      }
      const std::string descriptor(DotToDescriptor(class_name.c_str()));
      const size_t hash(ComputeModifiedUtf8Hash(descriptor.c_str()));
      for (const DexFile* dex_file : *dex_files) {
          const DexFile::ClassDef* dex_class_def =   dex_file->FindClassDef(descriptor.c_str(), hash);
          if (dex_class_def != nullptr) {
              ScopedObjectAccess soa(env);
              ClassLinker* class_linker =   Runtime::Current()->GetClassLinker();
                class_linker->RegisterDexFile(*dex_file);
              StackHandleScope<1> hs(soa.Self());
                Handle<mirror::ClassLoader> class_loader(
                        hs.NewHandle(soa.Decode<mirror::ClassLoader*>(javaLoader)));
              mirror::Class* result =   class_linker->DefineClass(soa.Self(), descriptor.c_str(), hash,
                      class_loader,   *dex_file, *dex_class_def);
              if (result != nullptr) {
                  VLOG(class_linker)   << "DexFile_defineClassNative   returning "   << result;
                  return   soa.AddLocalReference<jclass>(result);
              }
          }
      }
      VLOG(class_linker) << "Failed to find   dex_class_def";
      return nullptr;
  }

1
  2
  3
  4
  5
  6
  7
  8
  9
  10
  11
  12
  13
  14
  15
  16
  17
  18
  19
  20
  21
  22
  23
  24
  25
  26
  27
  28
  29
  30
  31
  32
  33
  34
  35
  36

void ClassLinker::LoadClass(const DexFile& dex_file,const DexFile::ClassDef&   dex_class_def,Handle<mirror::Class> klass,mirror::ClassLoader*   class_loader) {
      CHECK(klass.Get() != nullptr);
      CHECK(klass->GetDexCache() != nullptr);
        CHECK_EQ(mirror::Class::kStatusNotReady, klass->GetStatus());
      const char* descriptor =   dex_file.GetClassDescriptor(dex_class_def);
      CHECK(descriptor != nullptr);
 
        klass->SetClass(GetClassRoot(kJavaLangClass));
      if (kUseBakerOrBrooksReadBarrier) {
           klass->AssertReadBarrierPointer();
      }
      uint32_t access_flags =   dex_class_def.GetJavaAccessFlags();
      CHECK_EQ(access_flags &   ~kAccJavaFlagsMask, 0U);
        klass->SetAccessFlags(access_flags);
        klass->SetClassLoader(class_loader);
        DCHECK_EQ(klass->GetPrimitiveType(), Primitive::kPrimNot);
      klass->SetStatus(mirror::Class::kStatusIdx,   nullptr);
 
        klass->SetDexClassDefIndex(dex_file.GetIndexForClassDef(dex_class_def));
        klass->SetDexTypeIndex(dex_class_def.class_idx_);
        CHECK(klass->GetDexCacheStrings() != nullptr);
 
      const byte* class_data = dex_file.GetClassData(dex_class_def);
      if (class_data == nullptr) {
           return;  // no fields or methods - for example   a marker interface
      }
 
      OatFile::OatClass oat_class;
      if (Runtime::Current()->IsStarted()
      && !Runtime::Current()->UseCompileTimeClassPath()
      && FindOatClass(dex_file,   klass->GetDexClassDefIndex(), &oat_class)) {
           LoadClassMembers(dex_file,   class_data, klass, class_loader, &oat_class);
      } else {
           LoadClassMembers(dex_file,   class_data, klass, class_loader, nullptr);
      }
  }

1
  2
  3
  4

OatFile::OatMethod::OatMethod(const byte* base,const uint32_t code_offset)
          : begin_(base),
          code_offset_(code_offset) {
  }