| /* |
| * Copyright (C) 2016 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; |
| |
| import android.content.BroadcastReceiver; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.IntentFilter; |
| import android.content.pm.ActivityInfo; |
| import android.content.pm.ApplicationInfo; |
| import android.content.pm.PackageManager; |
| import android.content.pm.ResolveInfo; |
| import android.net.Uri; |
| import android.os.Binder; |
| import android.os.Build; |
| import android.os.Handler; |
| import android.os.Looper; |
| import android.os.Message; |
| import android.os.UserHandle; |
| import android.provider.MediaStore; |
| import android.system.ErrnoException; |
| import android.system.Os; |
| import android.system.OsConstants; |
| import android.system.StructStat; |
| import android.util.ArraySet; |
| import android.util.Slog; |
| |
| import com.android.internal.app.ResolverActivity; |
| import com.android.internal.os.BackgroundThread; |
| import com.android.internal.util.DumpUtils; |
| |
| import dalvik.system.DexFile; |
| import dalvik.system.VMRuntime; |
| |
| import java.io.FileDescriptor; |
| import java.io.IOException; |
| import java.io.PrintWriter; |
| import java.util.ArrayList; |
| |
| /** |
| * <p>PinnerService pins important files for key processes in memory.</p> |
| * <p>Files to pin are specified in the config_defaultPinnerServiceFiles |
| * overlay.</p> |
| * <p>Pin the default camera application if specified in config_pinnerCameraApp.</p> |
| */ |
| public final class PinnerService extends SystemService { |
| private static final boolean DEBUG = false; |
| private static final String TAG = "PinnerService"; |
| |
| private final Context mContext; |
| private final ArrayList<PinnedFile> mPinnedFiles = new ArrayList<PinnedFile>(); |
| private final ArrayList<PinnedFile> mPinnedCameraFiles = new ArrayList<PinnedFile>(); |
| private final boolean mShouldPinCamera; |
| |
| private BinderService mBinderService; |
| |
| private final long MAX_CAMERA_PIN_SIZE = 80 * (1 << 20); //80MB max |
| |
| private PinnerHandler mPinnerHandler = null; |
| |
| private final BroadcastReceiver mBroadcastReceiver = new BroadcastReceiver() { |
| @Override |
| public void onReceive(Context context, Intent intent) { |
| // If this user's camera app has been updated, update pinned files accordingly. |
| if (intent.getAction() == Intent.ACTION_PACKAGE_REPLACED) { |
| Uri packageUri = intent.getData(); |
| String packageName = packageUri.getSchemeSpecificPart(); |
| ArraySet<String> updatedPackages = new ArraySet<>(); |
| updatedPackages.add(packageName); |
| update(updatedPackages); |
| } |
| } |
| }; |
| |
| public PinnerService(Context context) { |
| super(context); |
| |
| mContext = context; |
| mShouldPinCamera = context.getResources().getBoolean( |
| com.android.internal.R.bool.config_pinnerCameraApp); |
| mPinnerHandler = new PinnerHandler(BackgroundThread.get().getLooper()); |
| |
| IntentFilter filter = new IntentFilter(); |
| filter.addAction(Intent.ACTION_PACKAGE_REPLACED); |
| filter.addDataScheme("package"); |
| mContext.registerReceiver(mBroadcastReceiver, filter); |
| } |
| |
| @Override |
| public void onStart() { |
| if (DEBUG) { |
| Slog.i(TAG, "Starting PinnerService"); |
| } |
| mBinderService = new BinderService(); |
| publishBinderService("pinner", mBinderService); |
| publishLocalService(PinnerService.class, this); |
| |
| mPinnerHandler.obtainMessage(PinnerHandler.PIN_ONSTART_MSG).sendToTarget(); |
| mPinnerHandler.obtainMessage(PinnerHandler.PIN_CAMERA_MSG, UserHandle.USER_SYSTEM, 0) |
| .sendToTarget(); |
| } |
| |
| /** |
| * Pin camera on user switch. |
| * If more than one user is using the device |
| * each user may set a different preference for the camera app. |
| * Make sure that user's preference is pinned into memory. |
| */ |
| @Override |
| public void onSwitchUser(int userHandle) { |
| mPinnerHandler.obtainMessage(PinnerHandler.PIN_CAMERA_MSG, userHandle, 0).sendToTarget(); |
| } |
| |
| /** |
| * Update the currently pinned files. |
| * Specifically, this only updates camera pinning. |
| * The other files pinned in onStart will not need to be updated. |
| */ |
| public void update(ArraySet<String> updatedPackages) { |
| ApplicationInfo cameraInfo = getCameraInfo(UserHandle.USER_SYSTEM); |
| if (cameraInfo != null && updatedPackages.contains(cameraInfo.packageName)) { |
| Slog.i(TAG, "Updating pinned files."); |
| mPinnerHandler.obtainMessage(PinnerHandler.PIN_CAMERA_MSG, UserHandle.USER_SYSTEM, 0) |
| .sendToTarget(); |
| } |
| } |
| |
| /** |
| * Handler for on start pinning message |
| */ |
| private void handlePinOnStart() { |
| // Files to pin come from the overlay and can be specified per-device config |
| String[] filesToPin = mContext.getResources().getStringArray( |
| com.android.internal.R.array.config_defaultPinnerServiceFiles); |
| synchronized(this) { |
| // Continue trying to pin remaining files even if there is a failure |
| for (int i = 0; i < filesToPin.length; i++){ |
| PinnedFile pf = pinFile(filesToPin[i], 0, 0, 0); |
| if (pf != null) { |
| mPinnedFiles.add(pf); |
| if (DEBUG) { |
| Slog.i(TAG, "Pinned file = " + pf.mFilename); |
| } |
| } else { |
| Slog.e(TAG, "Failed to pin file = " + filesToPin[i]); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Handler for camera pinning message |
| */ |
| private void handlePinCamera(int userHandle) { |
| if (mShouldPinCamera) { |
| synchronized(this) { |
| boolean success = pinCamera(userHandle); |
| if (!success) { |
| //this is not necessarily an error |
| if (DEBUG) { |
| Slog.v(TAG, "Failed to pin camera."); |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| * determine if the camera app is already pinned by comparing the |
| * intent resolution to the pinned files list |
| */ |
| private boolean alreadyPinned(int userHandle) { |
| ApplicationInfo cameraInfo = getCameraInfo(userHandle); |
| if (cameraInfo == null ) { |
| return false; |
| } |
| for (int i = 0; i < mPinnedCameraFiles.size(); i++) { |
| if (mPinnedCameraFiles.get(i).mFilename.equals(cameraInfo.sourceDir)) { |
| if (DEBUG) { |
| Slog.v(TAG, "Camera is already pinned"); |
| } |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| private void unpinCameraApp() { |
| for (int i = 0; i < mPinnedCameraFiles.size(); i++) { |
| unpinFile(mPinnedCameraFiles.get(i)); |
| } |
| mPinnedCameraFiles.clear(); |
| } |
| |
| private boolean isResolverActivity(ActivityInfo info) { |
| return ResolverActivity.class.getName().equals(info.name); |
| } |
| |
| private ApplicationInfo getCameraInfo(int userHandle) { |
| // find the camera via an intent |
| // use INTENT_ACTION_STILL_IMAGE_CAMERA instead of _SECURE. On a |
| // device without a fbe enabled, the _SECURE intent will never get set. |
| Intent cameraIntent = new Intent(MediaStore.INTENT_ACTION_STILL_IMAGE_CAMERA); |
| PackageManager pm = mContext.getPackageManager(); |
| ResolveInfo cameraResolveInfo = pm.resolveActivityAsUser(cameraIntent, |
| PackageManager.MATCH_DEFAULT_ONLY | PackageManager.MATCH_DIRECT_BOOT_AWARE |
| | PackageManager.MATCH_DIRECT_BOOT_UNAWARE, |
| userHandle); |
| if (cameraResolveInfo == null ) { |
| //this is not necessarily an error |
| if (DEBUG) { |
| Slog.v(TAG, "Unable to resolve camera intent"); |
| } |
| return null; |
| } |
| |
| if (isResolverActivity(cameraResolveInfo.activityInfo)) |
| { |
| if (DEBUG) { |
| Slog.v(TAG, "cameraIntent returned resolverActivity"); |
| } |
| return null; |
| } |
| |
| return cameraResolveInfo.activityInfo.applicationInfo; |
| } |
| |
| /** |
| * If the camera app is already pinned, unpin and repin it. |
| */ |
| private boolean pinCamera(int userHandle){ |
| ApplicationInfo cameraInfo = getCameraInfo(userHandle); |
| if (cameraInfo == null) { |
| return false; |
| } |
| |
| //unpin after checking that the camera intent has resolved |
| //this prevents us from thrashing when switching users with |
| //FBE enabled, because the intent won't resolve until the unlock |
| unpinCameraApp(); |
| |
| //pin APK |
| String camAPK = cameraInfo.sourceDir; |
| PinnedFile pf = pinFile(camAPK, 0, 0, MAX_CAMERA_PIN_SIZE); |
| if (pf == null) { |
| Slog.e(TAG, "Failed to pin " + camAPK); |
| return false; |
| } |
| if (DEBUG) { |
| Slog.i(TAG, "Pinned " + pf.mFilename); |
| } |
| mPinnedCameraFiles.add(pf); |
| |
| // determine the ABI from either ApplicationInfo or Build |
| String arch = "arm"; |
| if (cameraInfo.primaryCpuAbi != null) { |
| if (VMRuntime.is64BitAbi(cameraInfo.primaryCpuAbi)) { |
| arch = arch + "64"; |
| } |
| } else { |
| if (VMRuntime.is64BitAbi(Build.SUPPORTED_ABIS[0])) { |
| arch = arch + "64"; |
| } |
| } |
| |
| // get the path to the odex or oat file |
| String baseCodePath = cameraInfo.getBaseCodePath(); |
| String[] files = null; |
| try { |
| files = DexFile.getDexFileOutputPaths(baseCodePath, arch); |
| } catch (IOException ioe) {} |
| if (files == null) { |
| return true; |
| } |
| |
| //not pinning the oat/odex is not a fatal error |
| for (String file : files) { |
| pf = pinFile(file, 0, 0, MAX_CAMERA_PIN_SIZE); |
| if (pf != null) { |
| mPinnedCameraFiles.add(pf); |
| if (DEBUG) { |
| Slog.i(TAG, "Pinned " + pf.mFilename); |
| } |
| } |
| } |
| |
| return true; |
| } |
| |
| |
| /** mlock length bytes of fileToPin in memory, starting at offset |
| * length == 0 means pin from offset to end of file |
| * maxSize == 0 means infinite |
| */ |
| private static PinnedFile pinFile(String fileToPin, long offset, long length, long maxSize) { |
| FileDescriptor fd = new FileDescriptor(); |
| try { |
| fd = Os.open(fileToPin, |
| OsConstants.O_RDONLY | OsConstants.O_CLOEXEC | OsConstants.O_NOFOLLOW, |
| OsConstants.O_RDONLY); |
| |
| StructStat sb = Os.fstat(fd); |
| |
| if (offset + length > sb.st_size) { |
| Os.close(fd); |
| Slog.e(TAG, "Failed to pin file " + fileToPin + |
| ", request extends beyond end of file. offset + length = " |
| + (offset + length) + ", file length = " + sb.st_size); |
| return null; |
| } |
| |
| if (length == 0) { |
| length = sb.st_size - offset; |
| } |
| |
| if (maxSize > 0 && length > maxSize) { |
| Slog.e(TAG, "Could not pin file " + fileToPin + |
| ", size = " + length + ", maxSize = " + maxSize); |
| Os.close(fd); |
| return null; |
| } |
| |
| long address = Os.mmap(0, length, OsConstants.PROT_READ, |
| OsConstants.MAP_PRIVATE, fd, offset); |
| Os.close(fd); |
| |
| Os.mlock(address, length); |
| |
| return new PinnedFile(address, length, fileToPin); |
| } catch (ErrnoException e) { |
| Slog.e(TAG, "Could not pin file " + fileToPin + " with error " + e.getMessage()); |
| if(fd.valid()) { |
| try { |
| Os.close(fd); |
| } |
| catch (ErrnoException eClose) { |
| Slog.e(TAG, "Failed to close fd, error = " + eClose.getMessage()); |
| } |
| } |
| return null; |
| } |
| } |
| |
| private static boolean unpinFile(PinnedFile pf) { |
| try { |
| Os.munlock(pf.mAddress, pf.mLength); |
| } catch (ErrnoException e) { |
| Slog.e(TAG, "Failed to unpin file " + pf.mFilename + " with error " + e.getMessage()); |
| return false; |
| } |
| if (DEBUG) { |
| Slog.i(TAG, "Unpinned file " + pf.mFilename ); |
| } |
| return true; |
| } |
| |
| private final class BinderService extends Binder { |
| @Override |
| protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) { |
| if (!DumpUtils.checkDumpPermission(mContext, TAG, pw)) return; |
| pw.println("Pinned Files:"); |
| synchronized(this) { |
| for (int i = 0; i < mPinnedFiles.size(); i++) { |
| pw.println(mPinnedFiles.get(i).mFilename); |
| } |
| for (int i = 0; i < mPinnedCameraFiles.size(); i++) { |
| pw.println(mPinnedCameraFiles.get(i).mFilename); |
| } |
| } |
| } |
| } |
| |
| private static class PinnedFile { |
| long mAddress; |
| long mLength; |
| String mFilename; |
| |
| PinnedFile(long address, long length, String filename) { |
| mAddress = address; |
| mLength = length; |
| mFilename = filename; |
| } |
| } |
| |
| final class PinnerHandler extends Handler { |
| static final int PIN_CAMERA_MSG = 4000; |
| static final int PIN_ONSTART_MSG = 4001; |
| |
| public PinnerHandler(Looper looper) { |
| super(looper, null, true); |
| } |
| |
| @Override |
| public void handleMessage(Message msg) { |
| switch (msg.what) { |
| |
| case PIN_CAMERA_MSG: |
| { |
| handlePinCamera(msg.arg1); |
| } |
| break; |
| |
| case PIN_ONSTART_MSG: |
| { |
| handlePinOnStart(); |
| } |
| break; |
| |
| default: |
| super.handleMessage(msg); |
| } |
| } |
| } |
| |
| } |