PackageDexOptimizer.java revision 693f997cc8b8c2ba8d3ed29627b2641dd86392a5 
1/*
2 * Copyright (C) 2015 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
17package com.android.server.pm;
18
19import android.annotation.Nullable;
20import android.content.Context;
21import android.content.pm.ApplicationInfo;
22import android.content.pm.PackageParser;
23import android.content.pm.PackageParser.Package;
24import android.os.Environment;
25import android.os.PowerManager;
26import android.os.UserHandle;
27import android.os.WorkSource;
28import android.os.storage.StorageManager;
29import android.util.ArraySet;
30import android.util.Log;
31import android.util.Slog;
32
33import com.android.internal.os.InstallerConnection.InstallerException;
34
35import java.io.File;
36import java.io.IOException;
37import java.util.ArrayList;
38import java.util.List;
39
40import dalvik.system.DexFile;
41
42import static com.android.server.pm.Installer.DEXOPT_BOOTCOMPLETE;
43import static com.android.server.pm.Installer.DEXOPT_DEBUGGABLE;
44import static com.android.server.pm.Installer.DEXOPT_PUBLIC;
45import static com.android.server.pm.Installer.DEXOPT_SAFEMODE;
46import static com.android.server.pm.Installer.DEXOPT_EXTRACTONLY;
47import static com.android.server.pm.InstructionSets.getAppDexInstructionSets;
48import static com.android.server.pm.InstructionSets.getDexCodeInstructionSets;
49
50/**
51 * Helper class for running dexopt command on packages.
52 */
53class PackageDexOptimizer {
54    private static final String TAG = "PackageManager.DexOptimizer";
55    static final String OAT_DIR_NAME = "oat";
56    // TODO b/19550105 Remove error codes and use exceptions
57    static final int DEX_OPT_SKIPPED = 0;
58    static final int DEX_OPT_PERFORMED = 1;
59    static final int DEX_OPT_DEFERRED = 2;
60    static final int DEX_OPT_FAILED = -1;
61
62    private static final boolean DEBUG_DEXOPT = PackageManagerService.DEBUG_DEXOPT;
63
64    private final Installer mInstaller;
65    private final Object mInstallLock;
66
67    private final PowerManager.WakeLock mDexoptWakeLock;
68    private volatile boolean mSystemReady;
69
70    PackageDexOptimizer(Installer installer, Object installLock, Context context,
71            String wakeLockTag) {
72        this.mInstaller = installer;
73        this.mInstallLock = installLock;
74
75        PowerManager powerManager = (PowerManager)context.getSystemService(Context.POWER_SERVICE);
76        mDexoptWakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, wakeLockTag);
77    }
78
79    protected PackageDexOptimizer(PackageDexOptimizer from) {
80        this.mInstaller = from.mInstaller;
81        this.mInstallLock = from.mInstallLock;
82        this.mDexoptWakeLock = from.mDexoptWakeLock;
83        this.mSystemReady = from.mSystemReady;
84    }
85
86    static boolean canOptimizePackage(PackageParser.Package pkg) {
87        return (pkg.applicationInfo.flags & ApplicationInfo.FLAG_HAS_CODE) != 0;
88    }
89
90    /**
91     * Performs dexopt on all code paths and libraries of the specified package for specified
92     * instruction sets.
93     *
94     * <p>Calls to {@link com.android.server.pm.Installer#dexopt} on {@link #mInstaller} are
95     * synchronized on {@link #mInstallLock}.
96     */
97    int performDexOpt(PackageParser.Package pkg, String[] instructionSets, boolean useProfiles,
98            boolean extractOnly) {
99        synchronized (mInstallLock) {
100            final boolean useLock = mSystemReady;
101            if (useLock) {
102                mDexoptWakeLock.setWorkSource(new WorkSource(pkg.applicationInfo.uid));
103                mDexoptWakeLock.acquire();
104            }
105            try {
106                return performDexOptLI(pkg, instructionSets, useProfiles, extractOnly);
107            } finally {
108                if (useLock) {
109                    mDexoptWakeLock.release();
110                }
111            }
112        }
113    }
114
115    /**
116     * Adjust the given dexopt-needed value. Can be overridden to influence the decision to
117     * optimize or not (and in what way).
118     */
119    protected int adjustDexoptNeeded(int dexoptNeeded) {
120        return dexoptNeeded;
121    }
122
123    /**
124     * Adjust the given dexopt flags that will be passed to the installer.
125     */
126    protected int adjustDexoptFlags(int dexoptFlags) {
127        return dexoptFlags;
128    }
129
130    private int performDexOptLI(PackageParser.Package pkg, String[] targetInstructionSets,
131            boolean useProfiles, boolean extractOnly) {
132        final String[] instructionSets = targetInstructionSets != null ?
133                targetInstructionSets : getAppDexInstructionSets(pkg.applicationInfo);
134
135        if (!canOptimizePackage(pkg)) {
136            return DEX_OPT_SKIPPED;
137        }
138
139        final boolean vmSafeMode = (pkg.applicationInfo.flags & ApplicationInfo.FLAG_VM_SAFE_MODE) != 0;
140        final boolean debuggable = (pkg.applicationInfo.flags & ApplicationInfo.FLAG_DEBUGGABLE) != 0;
141
142        final List<String> paths = pkg.getAllCodePathsExcludingResourceOnly();
143        boolean performedDexOpt = false;
144        final String[] dexCodeInstructionSets = getDexCodeInstructionSets(instructionSets);
145        for (String dexCodeInstructionSet : dexCodeInstructionSets) {
146            for (String path : paths) {
147                if (useProfiles && isUsedByOtherApps(path)) {
148                    // We cannot use profile guided compilation if the apk was used by another app.
149                    useProfiles = false;
150                }
151                int dexoptNeeded;
152
153                try {
154                    int compilationTypeMask = 0;
155                    if (extractOnly) {
156                        // For extract only, any type of compilation is good.
157                        compilationTypeMask = DexFile.COMPILATION_TYPE_FULL
158                            | DexFile.COMPILATION_TYPE_PROFILE_GUIDE
159                            | DexFile.COMPILATION_TYPE_EXTRACT_ONLY;
160                    } else {
161                        // Branch taken for profile guide and full compilation.
162                        // Profile guide compilation should only recompile a previous
163                        // profile compiled/extract only file and should not be attempted if the
164                        // apk is already fully compiled. So test against a full compilation type.
165                        compilationTypeMask = DexFile.COMPILATION_TYPE_FULL;
166                    }
167                    dexoptNeeded = DexFile.getDexOptNeeded(path,
168                            dexCodeInstructionSet, compilationTypeMask);
169                } catch (IOException ioe) {
170                    Slog.w(TAG, "IOException reading apk: " + path, ioe);
171                    return DEX_OPT_FAILED;
172                }
173                dexoptNeeded = adjustDexoptNeeded(dexoptNeeded);
174
175                final String dexoptType;
176                String oatDir = null;
177                switch (dexoptNeeded) {
178                    case DexFile.NO_DEXOPT_NEEDED:
179                        continue;
180                    case DexFile.DEX2OAT_NEEDED:
181                        dexoptType = "dex2oat";
182                        oatDir = createOatDirIfSupported(pkg, dexCodeInstructionSet);
183                        break;
184                    case DexFile.PATCHOAT_NEEDED:
185                        dexoptType = "patchoat";
186                        break;
187                    case DexFile.SELF_PATCHOAT_NEEDED:
188                        dexoptType = "self patchoat";
189                        break;
190                    default:
191                        throw new IllegalStateException("Invalid dexopt:" + dexoptNeeded);
192                }
193
194
195                Log.i(TAG, "Running dexopt (" + dexoptType + ") on: " + path + " pkg="
196                        + pkg.applicationInfo.packageName + " isa=" + dexCodeInstructionSet
197                        + " vmSafeMode=" + vmSafeMode + " debuggable=" + debuggable
198                        + " extractOnly=" + extractOnly + " oatDir = " + oatDir);
199                final int sharedGid = UserHandle.getSharedAppGid(pkg.applicationInfo.uid);
200                // Profile guide compiled oat files should not be public.
201                final boolean isPublic = !pkg.isForwardLocked() && !useProfiles;
202                final int dexFlags = adjustDexoptFlags(
203                        ( isPublic ? DEXOPT_PUBLIC : 0)
204                        | (vmSafeMode ? DEXOPT_SAFEMODE : 0)
205                        | (debuggable ? DEXOPT_DEBUGGABLE : 0)
206                        | (extractOnly ? DEXOPT_EXTRACTONLY : 0)
207                        | DEXOPT_BOOTCOMPLETE);
208
209                try {
210                    mInstaller.dexopt(path, sharedGid, pkg.packageName, dexCodeInstructionSet,
211                            dexoptNeeded, oatDir, dexFlags, pkg.volumeUuid, useProfiles);
212                    performedDexOpt = true;
213                } catch (InstallerException e) {
214                    Slog.w(TAG, "Failed to dexopt", e);
215                }
216            }
217        }
218
219        // If we've gotten here, we're sure that no error occurred and that we haven't
220        // deferred dex-opt. We've either dex-opted one more paths or instruction sets or
221        // we've skipped all of them because they are up to date. In both cases this
222        // package doesn't need dexopt any longer.
223        return performedDexOpt ? DEX_OPT_PERFORMED : DEX_OPT_SKIPPED;
224    }
225
226    /**
227     * Creates oat dir for the specified package. In certain cases oat directory
228     * <strong>cannot</strong> be created:
229     * <ul>
230     *      <li>{@code pkg} is a system app, which is not updated.</li>
231     *      <li>Package location is not a directory, i.e. monolithic install.</li>
232     * </ul>
233     *
234     * @return Absolute path to the oat directory or null, if oat directory
235     * cannot be created.
236     */
237    @Nullable
238    private String createOatDirIfSupported(PackageParser.Package pkg, String dexInstructionSet) {
239        if (!pkg.canHaveOatDir()) {
240            return null;
241        }
242        File codePath = new File(pkg.codePath);
243        if (codePath.isDirectory()) {
244            File oatDir = getOatDir(codePath);
245            try {
246                mInstaller.createOatDir(oatDir.getAbsolutePath(), dexInstructionSet);
247            } catch (InstallerException e) {
248                Slog.w(TAG, "Failed to create oat dir", e);
249                return null;
250            }
251            return oatDir.getAbsolutePath();
252        }
253        return null;
254    }
255
256    static File getOatDir(File codePath) {
257        return new File(codePath, OAT_DIR_NAME);
258    }
259
260    void systemReady() {
261        mSystemReady = true;
262    }
263
264    private boolean isUsedByOtherApps(String apkPath) {
265        try {
266            apkPath = new File(apkPath).getCanonicalPath();
267        } catch (IOException e) {
268            // Log an error but continue without it.
269            Slog.w(TAG, "Failed to get canonical path", e);
270        }
271        String useMarker = apkPath.replace('/', '@');
272        final int[] currentUserIds = UserManagerService.getInstance().getUserIds();
273        for (int i = 0; i < currentUserIds.length; i++) {
274            File profileDir = Environment.getDataProfilesDeForeignDexDirectory(currentUserIds[i]);
275            File foreignUseMark = new File(profileDir, useMarker);
276            if (foreignUseMark.exists()) {
277                return true;
278            }
279        }
280        return false;
281    }
282
283    /**
284     * A specialized PackageDexOptimizer that overrides already-installed checks, forcing a
285     * dexopt path.
286     */
287    public static class ForcedUpdatePackageDexOptimizer extends PackageDexOptimizer {
288
289        public ForcedUpdatePackageDexOptimizer(Installer installer, Object installLock,
290                Context context, String wakeLockTag) {
291            super(installer, installLock, context, wakeLockTag);
292        }
293
294        public ForcedUpdatePackageDexOptimizer(PackageDexOptimizer from) {
295            super(from);
296        }
297
298        @Override
299        protected int adjustDexoptNeeded(int dexoptNeeded) {
300            // Ensure compilation, no matter the current state.
301            // TODO: The return value is wrong when patchoat is needed.
302            return DexFile.DEX2OAT_NEEDED;
303        }
304    }
305}
306