/* * Copyright (C) 2022 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.android.server.art; import static com.android.server.art.ArtManagerLocal.DexoptDoneCallback; import static com.android.server.art.model.Config.Callback; import static com.android.server.art.model.DexoptResult.DexContainerFileDexoptResult; import static com.android.server.art.model.DexoptResult.PackageDexoptResult; import android.annotation.NonNull; import android.annotation.Nullable; import android.apphibernation.AppHibernationManager; import android.content.Context; import android.os.Binder; import android.os.Build; import android.os.CancellationSignal; import android.os.PowerManager; import android.os.RemoteException; import android.os.WorkSource; import androidx.annotation.RequiresApi; import com.android.internal.annotations.VisibleForTesting; import com.android.server.art.model.ArtFlags; import com.android.server.art.model.Config; import com.android.server.art.model.DexoptParams; import com.android.server.art.model.DexoptResult; import com.android.server.art.model.OperationProgress; import com.android.server.pm.PackageManagerLocal; import com.android.server.pm.pkg.AndroidPackage; import com.android.server.pm.pkg.PackageState; import com.android.server.pm.pkg.SharedLibrary; import java.util.ArrayList; import java.util.HashSet; import java.util.LinkedHashMap; import java.util.LinkedList; import java.util.List; import java.util.Objects; import java.util.Queue; import java.util.Set; import java.util.concurrent.CompletableFuture; import java.util.concurrent.Executor; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicInteger; import java.util.function.Consumer; import java.util.function.Function; import java.util.stream.Collectors; /** * A helper class to handle dexopt. * * It talks to other components (e.g., PowerManager) and dispatches tasks to dexopters. * * @hide */ @RequiresApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE) public class DexoptHelper { private static final String TAG = ArtManagerLocal.TAG; /** * Timeout of the wake lock. This is required by AndroidLint, but we set it to a very large * value so that it should normally never triggered. */ private static final long WAKE_LOCK_TIMEOUT_MS = TimeUnit.DAYS.toMillis(1); @NonNull private final Injector mInjector; public DexoptHelper(@NonNull Context context, @NonNull Config config) { this(new Injector(context, config)); } @VisibleForTesting public DexoptHelper(@NonNull Injector injector) { mInjector = injector; } /** * DO NOT use this method directly. Use {@link ArtManagerLocal#dexoptPackage} or {@link * ArtManagerLocal#dexoptPackages}. */ @NonNull public DexoptResult dexopt(@NonNull PackageManagerLocal.FilteredSnapshot snapshot, @NonNull List packageNames, @NonNull DexoptParams params, @NonNull CancellationSignal cancellationSignal, @NonNull Executor dexoptExecutor) { return dexopt(snapshot, packageNames, params, cancellationSignal, dexoptExecutor, null /* progressCallbackExecutor */, null /* progressCallback */); } /** * DO NOT use this method directly. Use {@link ArtManagerLocal#dexoptPackage} or {@link * ArtManagerLocal#dexoptPackages}. */ @NonNull public DexoptResult dexopt(@NonNull PackageManagerLocal.FilteredSnapshot snapshot, @NonNull List packageNames, @NonNull DexoptParams params, @NonNull CancellationSignal cancellationSignal, @NonNull Executor dexoptExecutor, @Nullable Executor progressCallbackExecutor, @Nullable Consumer progressCallback) { return dexoptPackages( getPackageStates(snapshot, packageNames, (params.getFlags() & ArtFlags.FLAG_SHOULD_INCLUDE_DEPENDENCIES) != 0), params, cancellationSignal, dexoptExecutor, progressCallbackExecutor, progressCallback); } /** * DO NOT use this method directly. Use {@link ArtManagerLocal#dexoptPackage} or {@link * ArtManagerLocal#dexoptPackages}. */ @NonNull private DexoptResult dexoptPackages(@NonNull List pkgStates, @NonNull DexoptParams params, @NonNull CancellationSignal cancellationSignal, @NonNull Executor dexoptExecutor, @Nullable Executor progressCallbackExecutor, @Nullable Consumer progressCallback) { int callingUid = Binder.getCallingUid(); long identityToken = Binder.clearCallingIdentity(); PowerManager.WakeLock wakeLock = null; try { // Acquire a wake lock. PowerManager powerManager = mInjector.getPowerManager(); wakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG); wakeLock.setWorkSource(new WorkSource(callingUid)); wakeLock.acquire(WAKE_LOCK_TIMEOUT_MS); List> futures = new ArrayList<>(); // Child threads will set their own listeners on the cancellation signal, so we must // create a separate cancellation signal for each of them so that the listeners don't // overwrite each other. List childCancellationSignals = pkgStates.stream() .map(pkgState -> new CancellationSignal()) .collect(Collectors.toList()); cancellationSignal.setOnCancelListener(() -> { for (CancellationSignal childCancellationSignal : childCancellationSignals) { childCancellationSignal.cancel(); } }); for (int i = 0; i < pkgStates.size(); i++) { PackageState pkgState = pkgStates.get(i); CancellationSignal childCancellationSignal = childCancellationSignals.get(i); futures.add(CompletableFuture.supplyAsync(() -> { return dexoptPackage(pkgState, params, childCancellationSignal); }, dexoptExecutor)); } if (progressCallback != null) { CompletableFuture.runAsync(() -> { progressCallback.accept( OperationProgress.create(0 /* current */, futures.size())); }, progressCallbackExecutor); AtomicInteger current = new AtomicInteger(0); for (CompletableFuture future : futures) { future.thenRunAsync(() -> { progressCallback.accept(OperationProgress.create( current.incrementAndGet(), futures.size())); }, progressCallbackExecutor); } } List results = futures.stream().map(Utils::getFuture).collect(Collectors.toList()); var result = DexoptResult.create(params.getCompilerFilter(), params.getReason(), results); for (Callback doneCallback : mInjector.getConfig().getDexoptDoneCallbacks()) { boolean onlyIncludeUpdates = doneCallback.extra(); if (onlyIncludeUpdates) { List filteredResults = results.stream() .filter(PackageDexoptResult::hasUpdatedArtifacts) .collect(Collectors.toList()); if (!filteredResults.isEmpty()) { var resultForCallback = DexoptResult.create( params.getCompilerFilter(), params.getReason(), filteredResults); CompletableFuture.runAsync(() -> { doneCallback.get().onDexoptDone(resultForCallback); }, doneCallback.executor()); } } else { CompletableFuture.runAsync(() -> { doneCallback.get().onDexoptDone(result); }, doneCallback.executor()); } } return result; } finally { if (wakeLock != null) { wakeLock.release(); } Binder.restoreCallingIdentity(identityToken); // Make sure nothing leaks even if the caller holds `cancellationSignal` forever. cancellationSignal.setOnCancelListener(null); } } /** * DO NOT use this method directly. Use {@link ArtManagerLocal#dexoptPackage} or {@link * ArtManagerLocal#dexoptPackages}. */ @NonNull private PackageDexoptResult dexoptPackage(@NonNull PackageState pkgState, @NonNull DexoptParams params, @NonNull CancellationSignal cancellationSignal) { List results = new ArrayList<>(); Function createResult = (packageLevelStatus) -> PackageDexoptResult.create( pkgState.getPackageName(), results, packageLevelStatus); AndroidPackage pkg = Utils.getPackageOrThrow(pkgState); if (!canDexoptPackage(pkgState)) { return createResult.apply(null /* packageLevelStatus */); } if ((params.getFlags() & ArtFlags.FLAG_FOR_SINGLE_SPLIT) != 0) { // Throws if the split is not found. PrimaryDexUtils.getDexInfoBySplitName(pkg, params.getSplitName()); } try (var tracing = new Utils.Tracing("dexopt")) { if ((params.getFlags() & ArtFlags.FLAG_FOR_PRIMARY_DEX) != 0) { if (cancellationSignal.isCanceled()) { return createResult.apply(DexoptResult.DEXOPT_CANCELLED); } results.addAll( mInjector.getPrimaryDexopter(pkgState, pkg, params, cancellationSignal) .dexopt()); } if ((params.getFlags() & ArtFlags.FLAG_FOR_SECONDARY_DEX) != 0) { if (cancellationSignal.isCanceled()) { return createResult.apply(DexoptResult.DEXOPT_CANCELLED); } results.addAll( mInjector.getSecondaryDexopter(pkgState, pkg, params, cancellationSignal) .dexopt()); } } catch (RemoteException e) { Utils.logArtdException(e); return createResult.apply(DexoptResult.DEXOPT_FAILED); } return createResult.apply(null /* packageLevelStatus */); } private boolean canDexoptPackage(@NonNull PackageState pkgState) { // getAppHibernationManager may return null here during boot time compilation, which will // make this function return true incorrectly for packages that shouldn't be dexopted due to // hibernation. Further discussion in comments in ArtManagerLocal.getDefaultPackages. return Utils.canDexoptPackage(pkgState, mInjector.getAppHibernationManager()); } @NonNull private List getPackageStates( @NonNull PackageManagerLocal.FilteredSnapshot snapshot, @NonNull List packageNames, boolean includeDependencies) { var pkgStates = new LinkedHashMap(); Set visitedLibraries = new HashSet<>(); Queue queue = new LinkedList<>(); Consumer maybeEnqueue = library -> { // The package name is not null if the library is an APK. // TODO(jiakaiz): Support JAR libraries. if (library.getPackageName() != null && !library.isNative() && !visitedLibraries.contains(library.getName())) { visitedLibraries.add(library.getName()); queue.add(library); } }; for (String packageName : packageNames) { PackageState pkgState = Utils.getPackageStateOrThrow(snapshot, packageName); Utils.getPackageOrThrow(pkgState); pkgStates.put(packageName, pkgState); if (includeDependencies && canDexoptPackage(pkgState)) { for (SharedLibrary library : pkgState.getSharedLibraryDependencies()) { maybeEnqueue.accept(library); } } } SharedLibrary library; while ((library = queue.poll()) != null) { String packageName = library.getPackageName(); PackageState pkgState = Utils.getPackageStateOrThrow(snapshot, packageName); if (canDexoptPackage(pkgState)) { pkgStates.put(packageName, pkgState); // Note that `library.getDependencies()` is different from // `pkgState.getUsesLibraries()`. Different libraries can belong to the same // package. `pkgState.getUsesLibraries()` returns a union of dependencies of // libraries that belong to the same package, which is not what we want here. // Therefore, this loop cannot be unified with the one above. for (SharedLibrary dep : library.getDependencies()) { maybeEnqueue.accept(dep); } } } // `LinkedHashMap` guarantees deterministic order. return new ArrayList<>(pkgStates.values()); } /** * Injector pattern for testing purpose. * * @hide */ @VisibleForTesting public static class Injector { @NonNull private final Context mContext; @NonNull private final Config mConfig; Injector(@NonNull Context context, @NonNull Config config) { mContext = context; mConfig = config; // Call the getters for the dependencies that aren't optional, to ensure correct // initialization order. getAppHibernationManager(); getPowerManager(); } @NonNull PrimaryDexopter getPrimaryDexopter(@NonNull PackageState pkgState, @NonNull AndroidPackage pkg, @NonNull DexoptParams params, @NonNull CancellationSignal cancellationSignal) { return new PrimaryDexopter(mContext, pkgState, pkg, params, cancellationSignal); } @NonNull SecondaryDexopter getSecondaryDexopter(@NonNull PackageState pkgState, @NonNull AndroidPackage pkg, @NonNull DexoptParams params, @NonNull CancellationSignal cancellationSignal) { return new SecondaryDexopter(mContext, pkgState, pkg, params, cancellationSignal); } @NonNull public AppHibernationManager getAppHibernationManager() { return Objects.requireNonNull(mContext.getSystemService(AppHibernationManager.class)); } @NonNull public PowerManager getPowerManager() { return Objects.requireNonNull(mContext.getSystemService(PowerManager.class)); } @NonNull public Config getConfig() { return mConfig; } } }