PackageDexOptimizer.java revision 990fb6b5c91be62078a698ee1c01e24d33364c85 
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                Log.i(TAG, "Running dexopt (" + dexoptType + ") on: " + path + " pkg="
195                        + pkg.applicationInfo.packageName + " isa=" + dexCodeInstructionSet
196                        + " vmSafeMode=" + vmSafeMode + " debuggable=" + debuggable
197                        + " extractOnly=" + extractOnly + " oatDir = " + oatDir);
198                final int sharedGid = UserHandle.getSharedAppGid(pkg.applicationInfo.uid);
199                // Profile guide compiled oat files should not be public.
200                final boolean isPublic = !pkg.isForwardLocked() && !useProfiles;
201                final int dexFlags = adjustDexoptFlags(
202                        ( isPublic ? DEXOPT_PUBLIC : 0)
203                        | (vmSafeMode ? DEXOPT_SAFEMODE : 0)
204                        | (debuggable ? DEXOPT_DEBUGGABLE : 0)
205                        | (extractOnly ? DEXOPT_EXTRACTONLY : 0)
206                        | DEXOPT_BOOTCOMPLETE);
207
208                try {
209                    mInstaller.dexopt(path, sharedGid, pkg.packageName, dexCodeInstructionSet,
210                            dexoptNeeded, oatDir, dexFlags, pkg.volumeUuid, useProfiles);
211                    performedDexOpt = true;
212                } catch (InstallerException e) {
213                    Slog.w(TAG, "Failed to dexopt", e);
214                }
215            }
216        }
217
218        // If we've gotten here, we're sure that no error occurred and that we haven't
219        // deferred dex-opt. We've either dex-opted one more paths or instruction sets or
220        // we've skipped all of them because they are up to date. In both cases this
221        // package doesn't need dexopt any longer.
222        return performedDexOpt ? DEX_OPT_PERFORMED : DEX_OPT_SKIPPED;
223    }
224
225    /**
226     * Creates oat dir for the specified package. In certain cases oat directory
227     * <strong>cannot</strong> be created:
228     * <ul>
229     *      <li>{@code pkg} is a system app, which is not updated.</li>
230     *      <li>Package location is not a directory, i.e. monolithic install.</li>
231     * </ul>
232     *
233     * @return Absolute path to the oat directory or null, if oat directory
234     * cannot be created.
235     */
236    @Nullable
237    private String createOatDirIfSupported(PackageParser.Package pkg, String dexInstructionSet) {
238        if (!pkg.canHaveOatDir()) {
239            return null;
240        }
241        File codePath = new File(pkg.codePath);
242        if (codePath.isDirectory()) {
243            File oatDir = getOatDir(codePath);
244            try {
245                mInstaller.createOatDir(oatDir.getAbsolutePath(), dexInstructionSet);
246            } catch (InstallerException e) {
247                Slog.w(TAG, "Failed to create oat dir", e);
248                return null;
249            }
250            return oatDir.getAbsolutePath();
251        }
252        return null;
253    }
254
255    static File getOatDir(File codePath) {
256        return new File(codePath, OAT_DIR_NAME);
257    }
258
259    void systemReady() {
260        mSystemReady = true;
261    }
262
263    private boolean isUsedByOtherApps(String apkPath) {
264        try {
265            apkPath = new File(apkPath).getCanonicalPath();
266        } catch (IOException e) {
267            // Log an error but continue without it.
268            Slog.w(TAG, "Failed to get canonical path", e);
269        }
270        String useMarker = apkPath.replace('/', '@');
271        final int[] currentUserIds = UserManagerService.getInstance().getUserIds();
272        for (int i = 0; i < currentUserIds.length; i++) {
273            File profileDir = Environment.getDataProfilesDeForeignDexDirectory(currentUserIds[i]);
274            File foreignUseMark = new File(profileDir, useMarker);
275            if (foreignUseMark.exists()) {
276                return true;
277            }
278        }
279        return false;
280    }
281
282    /**
283     * A specialized PackageDexOptimizer that overrides already-installed checks, forcing a
284     * dexopt path.
285     */
286    public static class ForcedUpdatePackageDexOptimizer extends PackageDexOptimizer {
287
288        public ForcedUpdatePackageDexOptimizer(Installer installer, Object installLock,
289                Context context, String wakeLockTag) {
290            super(installer, installLock, context, wakeLockTag);
291        }
292
293        public ForcedUpdatePackageDexOptimizer(PackageDexOptimizer from) {
294            super(from);
295        }
296
297        @Override
298        protected int adjustDexoptNeeded(int dexoptNeeded) {
299            // Ensure compilation, no matter the current state.
300            // TODO: The return value is wrong when patchoat is needed.
301            return DexFile.DEX2OAT_NEEDED;
302        }
303    }
304}
305