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

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()]);
}

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);
    }
}

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;
    }
}

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;
    }
}

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;
}

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++;
}

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

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;
}

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;
}

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);
    }
}

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