// Copyright 2017 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
package org.chromium.base.process_launcher;
import android.content.ComponentName;
import android.content.Context;
import android.content.pm.ApplicationInfo;
import android.content.pm.PackageManager;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.Looper;
import android.os.UserManager;
import androidx.annotation.VisibleForTesting;
import androidx.collection.ArraySet;
import org.chromium.base.BuildInfo;
import org.chromium.base.ContextUtils;
import org.chromium.base.JavaUtils;
import org.chromium.base.Log;
import org.chromium.base.ResettersForTesting;
import org.chromium.base.SysUtils;
import java.lang.reflect.Method;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Queue;
/**
* This class is responsible for allocating and managing connections to child
* process services. These connections are in a pool (the services are defined
* in the AndroidManifest.xml).
*/
public abstract class ChildConnectionAllocator {
private static final String TAG = "ChildConnAllocator";
private static final String ZYGOTE_SUFFIX = "0";
private static final String NON_ZYGOTE_SUFFIX = "1";
/** Factory interface. Used by tests to specialize created connections. */
@VisibleForTesting
public interface ConnectionFactory {
ChildProcessConnection createConnection(
Context context,
ComponentName serviceName,
ComponentName fallbackServiceName,
boolean bindToCaller,
boolean bindAsExternalService,
Bundle serviceBundle,
String instanceName);
}
/** Default implementation of the ConnectionFactory that creates actual connections. */
private static class ConnectionFactoryImpl implements ConnectionFactory {
@Override
public ChildProcessConnection createConnection(
Context context,
ComponentName serviceName,
ComponentName fallbackServiceName,
boolean bindToCaller,
boolean bindAsExternalService,
Bundle serviceBundle,
String instanceName) {
return new ChildProcessConnection(
context,
serviceName,
fallbackServiceName,
bindToCaller,
bindAsExternalService,
serviceBundle,
instanceName);
}
}
// Delay between the call to freeConnection and the connection actually beeing freed.
private static final long FREE_CONNECTION_DELAY_MILLIS = 1;
// Max number of connections allocated for variable allocator.
// Android allocates 100 UIDs for a zygote, but unbinding and killing a service is not
// synchronous. So leave 2 to leave some time for ActivityManager to respond.
private static final int MAX_VARIABLE_ALLOCATED = 98;
// Runnable which will be called when allocator wants to allocate a new connection, but does
// not have any more free slots. May be null.
private final Runnable mFreeSlotCallback;
private final Queue<Runnable> mPendingAllocations = new ArrayDeque<>();
// The handler of the thread on which all interations should happen.
private final Handler mLauncherHandler;
/* package */ final String mPackageName;
/* package */ final String mServiceClassName;
/* package */ final String mFallbackServiceClassName;
/* package */ final boolean mBindToCaller;
/* package */ final boolean mBindAsExternalService;
/* package */ final boolean mUseStrongBinding;
/* package */ ConnectionFactory mConnectionFactory = new ConnectionFactoryImpl();
// Need to call an internal method to work around a framework bug.
@SuppressWarnings("PrivateApi")
private static void workAroundWebViewPackageVisibility() {
try {
Class wvus = Class.forName("android.webkit.WebViewUpdateService");
Method getWVPN = wvus.getDeclaredMethod("getCurrentWebViewPackageName");
// Calling this for the side effect of granting implicit visibility..
getWVPN.invoke(null);
} catch (Exception e) {
// Don't crash the host app; the workaround is only necessary in a few special cases,
// so failing is okay.
Log.w(TAG, "workAroundWebViewPackageVisibility failed", e);
}
}
private static void checkServiceExists(
Context context, String packageName, String serviceClassName) {
// On R/S/T it's possible for the app to lose visibility of the WebView package in rare
// cases; see crbug.com/1363832 - we attempt to get re-granted visibility here to work
// around it.
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R
&& Build.VERSION.SDK_INT < Build.VERSION_CODES.UPSIDE_DOWN_CAKE
&& !packageName.equals(context.getPackageName())) {
workAroundWebViewPackageVisibility();
}
PackageManager packageManager = context.getPackageManager();
// Check that the service exists.
try {
// PackageManager#getServiceInfo() throws an exception if the service does not exist.
packageManager.getServiceInfo(
new ComponentName(packageName, serviceClassName + "0"), 0);
} catch (PackageManager.NameNotFoundException e) {
JavaUtils.throwUnchecked(e);
}
}
/**
* Factory method that retrieves the service name and number of service from the
* AndroidManifest.xml.
*/
public static ChildConnectionAllocator create(
Context context,
Handler launcherHandler,
Runnable freeSlotCallback,
String packageName,
String serviceClassName,
String numChildServicesManifestKey,
boolean bindToCaller,
boolean bindAsExternalService,
boolean useStrongBinding) {
int numServices = -1;
PackageManager packageManager = context.getPackageManager();
try {
ApplicationInfo appInfo =
packageManager.getApplicationInfo(packageName, PackageManager.GET_META_DATA);
if (appInfo.metaData != null) {
numServices = appInfo.metaData.getInt(numChildServicesManifestKey, -1);
}
} catch (PackageManager.NameNotFoundException e) {
JavaUtils.throwUnchecked(e);
}
if (numServices < 0) {
throw new RuntimeException();
}
checkServiceExists(context, packageName, serviceClassName);
return new FixedSizeAllocatorImpl(
launcherHandler,
freeSlotCallback,
packageName,
serviceClassName,
bindToCaller,
bindAsExternalService,
useStrongBinding,
numServices);
}
public static ChildConnectionAllocator createVariableSize(
Context context,
Handler launcherHandler,
Runnable freeSlotCallback,
String packageName,
String serviceClassName,
boolean bindToCaller,
boolean bindAsExternalService,
boolean useStrongBinding) {
checkServiceExists(context, packageName, serviceClassName);
// OnePlus devices are having trouble with app zygote in combination with dynamic
// feature modules. See crbug.com/1064314 for details.
BuildInfo buildInfo = BuildInfo.getInstance();
boolean disableZygote =
Build.VERSION.SDK_INT == 29
&& buildInfo.androidBuildFingerprint.startsWith("OnePlus/");
if (Build.VERSION.SDK_INT == 29 && !disableZygote) {
UserManager userManager =
(UserManager)
ContextUtils.getApplicationContext()
.getSystemService(Context.USER_SERVICE);
if (!userManager.isSystemUser()) {
return new Android10WorkaroundAllocatorImpl(
launcherHandler,
freeSlotCallback,
packageName,
serviceClassName,
bindToCaller,
bindAsExternalService,
useStrongBinding,
MAX_VARIABLE_ALLOCATED);
}
}
// On low end devices, we do not expect to have many renderers. As a consequence, the fixed
// costs of the app zygote are not recovered. See https://crbug.com/1044579 for context and
// experimental results.
disableZygote = SysUtils.isLowEndDevice() || disableZygote;
String suffix = disableZygote ? NON_ZYGOTE_SUFFIX : ZYGOTE_SUFFIX;
String fallbackServiceClassName =
disableZygote ? null : serviceClassName + NON_ZYGOTE_SUFFIX;
return new VariableSizeAllocatorImpl(
launcherHandler,
freeSlotCallback,
packageName,
serviceClassName + suffix,
fallbackServiceClassName,
bindToCaller,
bindAsExternalService,
useStrongBinding,
MAX_VARIABLE_ALLOCATED);
}
/**
* Factory method used with some tests to create an allocator with values passed in directly
* instead of being retrieved from the AndroidManifest.xml.
*/
public static FixedSizeAllocatorImpl createFixedForTesting(
Runnable freeSlotCallback,
String packageName,
String serviceClassName,
int serviceCount,
boolean bindToCaller,
boolean bindAsExternalService,
boolean useStrongBinding) {
return new FixedSizeAllocatorImpl(
new Handler(),
freeSlotCallback,
packageName,
serviceClassName,
bindToCaller,
bindAsExternalService,
useStrongBinding,
serviceCount);
}
public static VariableSizeAllocatorImpl createVariableSizeForTesting(
Handler launcherHandler,
String packageName,
Runnable freeSlotCallback,
String serviceClassName,
boolean bindToCaller,
boolean bindAsExternalService,
boolean useStrongBinding,
int maxAllocated) {
return new VariableSizeAllocatorImpl(
launcherHandler,
freeSlotCallback,
packageName,
serviceClassName + ZYGOTE_SUFFIX,
null,
bindToCaller,
bindAsExternalService,
useStrongBinding,
maxAllocated);
}
public static Android10WorkaroundAllocatorImpl createWorkaroundForTesting(
Handler launcherHandler,
String packageName,
Runnable freeSlotCallback,
String serviceClassName,
boolean bindToCaller,
boolean bindAsExternalService,
boolean useStrongBinding,
int maxAllocated) {
return new Android10WorkaroundAllocatorImpl(
launcherHandler,
freeSlotCallback,
packageName,
serviceClassName,
bindToCaller,
bindAsExternalService,
useStrongBinding,
maxAllocated);
}
private ChildConnectionAllocator(
Handler launcherHandler,
Runnable freeSlotCallback,
String packageName,
String serviceClassName,
String fallbackServiceClassName,
boolean bindToCaller,
boolean bindAsExternalService,
boolean useStrongBinding) {
mLauncherHandler = launcherHandler;
assert isRunningOnLauncherThread();
mFreeSlotCallback = freeSlotCallback;
mPackageName = packageName;
mServiceClassName = serviceClassName;
mFallbackServiceClassName = fallbackServiceClassName;
mBindToCaller = bindToCaller;
mBindAsExternalService = bindAsExternalService;
mUseStrongBinding = useStrongBinding;
}
/**
* @return a bound connection, or null if there are no free slots.
*/
public ChildProcessConnection allocate(
Context context,
Bundle serviceBundle,
final ChildProcessConnection.ServiceCallback serviceCallback) {
assert isRunningOnLauncherThread();
// Wrap the service callbacks so that:
// - we can intercept onChildProcessDied and clean-up connections
// - the callbacks are actually posted so that this method will return before the callbacks
// are called (so that the caller may set any reference to the returned connection before
// any callback logic potentially tries to access that connection).
ChildProcessConnection.ServiceCallback serviceCallbackWrapper =
new ChildProcessConnection.ServiceCallback() {
@Override
public void onChildStarted() {
assert isRunningOnLauncherThread();
if (serviceCallback != null) {
mLauncherHandler.post(
new Runnable() {
@Override
public void run() {
serviceCallback.onChildStarted();
}
});
}
}
@Override
public void onChildStartFailed(final ChildProcessConnection connection) {
assert isRunningOnLauncherThread();
if (serviceCallback != null) {
mLauncherHandler.post(
new Runnable() {
@Override
public void run() {
serviceCallback.onChildStartFailed(connection);
}
});
}
freeConnectionWithDelay(connection);
}
@Override
public void onChildProcessDied(final ChildProcessConnection connection) {
assert isRunningOnLauncherThread();
if (serviceCallback != null) {
mLauncherHandler.post(
new Runnable() {
@Override
public void run() {
serviceCallback.onChildProcessDied(connection);
}
});
}
freeConnectionWithDelay(connection);
}
private void freeConnectionWithDelay(final ChildProcessConnection connection) {
// Freeing a service should be delayed. This is so that we avoid immediately
// reusing the freed service (see http://crbug.com/164069): the framework
// might keep a service process alive when it's been unbound for a short
// time. If a new connection to the same service is bound at that point, the
// process is reused and bad things happen (mostly static variables are set
// when we don't expect them to).
mLauncherHandler.postDelayed(
new Runnable() {
@Override
public void run() {
free(connection);
}
},
FREE_CONNECTION_DELAY_MILLIS);
}
};
return doAllocate(context, serviceBundle, serviceCallbackWrapper);
}
/** Free connection allocated by this allocator. */
private void free(ChildProcessConnection connection) {
assert isRunningOnLauncherThread();
doFree(connection);
if (mPendingAllocations.isEmpty()) return;
mPendingAllocations.remove().run();
if (!mPendingAllocations.isEmpty() && mFreeSlotCallback != null) {
mFreeSlotCallback.run();
}
}
public final void queueAllocation(Runnable runnable) {
assert isRunningOnLauncherThread();
boolean wasEmpty = mPendingAllocations.isEmpty();
mPendingAllocations.add(runnable);
if (wasEmpty && mFreeSlotCallback != null) mFreeSlotCallback.run();
}
/** May return -1 if size is not fixed. */
public abstract int getNumberOfServices();
@VisibleForTesting
public abstract boolean anyConnectionAllocated();
/** @return the count of connections managed by the allocator */
public abstract int allocatedConnectionsCountForTesting();
public void setConnectionFactoryForTesting(ConnectionFactory connectionFactory) {
var oldValue = mConnectionFactory;
mConnectionFactory = connectionFactory;
ResettersForTesting.register(() -> mConnectionFactory = oldValue);
}
private boolean isRunningOnLauncherThread() {
return mLauncherHandler.getLooper() == Looper.myLooper();
}
/* package */ abstract ChildProcessConnection doAllocate(
Context context,
Bundle serviceBundle,
ChildProcessConnection.ServiceCallback serviceCallback);
/* package */ abstract void doFree(ChildProcessConnection connection);
/** Implementation class accessed directly by tests. */
@VisibleForTesting
public static class FixedSizeAllocatorImpl extends ChildConnectionAllocator {
// Connections to services. Indices of the array correspond to the service numbers.
private final ChildProcessConnection[] mChildProcessConnections;
// The list of free (not bound) service indices.
private final ArrayList<Integer> mFreeConnectionIndices;
private FixedSizeAllocatorImpl(
Handler launcherHandler,
Runnable freeSlotCallback,
String packageName,
String serviceClassName,
boolean bindToCaller,
boolean bindAsExternalService,
boolean useStrongBinding,
int numChildServices) {
super(
launcherHandler,
freeSlotCallback,
packageName,
serviceClassName,
null,
bindToCaller,
bindAsExternalService,
useStrongBinding);
mChildProcessConnections = new ChildProcessConnection[numChildServices];
mFreeConnectionIndices = new ArrayList<Integer>(numChildServices);
for (int i = 0; i < numChildServices; i++) {
mFreeConnectionIndices.add(i);
}
}
@Override
/* package */ ChildProcessConnection doAllocate(
Context context,
Bundle serviceBundle,
ChildProcessConnection.ServiceCallback serviceCallback) {
if (mFreeConnectionIndices.isEmpty()) {
Log.w(TAG, "Ran out of services to allocate.");
return null;
}
int slot = mFreeConnectionIndices.remove(0);
assert mChildProcessConnections[slot] == null;
ComponentName serviceName = new ComponentName(mPackageName, mServiceClassName + slot);
ComponentName fallbackServiceName = null;
ChildProcessConnection connection =
mConnectionFactory.createConnection(
context,
serviceName,
fallbackServiceName,
mBindToCaller,
mBindAsExternalService,
serviceBundle,
/* instanceName= */ null);
mChildProcessConnections[slot] = connection;
Log.d(
TAG,
"Allocator allocated and bound a connection, name: %s, slot: %d",
mServiceClassName,
slot);
connection.start(mUseStrongBinding, serviceCallback);
return connection;
}
@Override
/* package */ void doFree(ChildProcessConnection connection) {
// mChildProcessConnections is relatively short (40 items at max at this point).
// We are better of iterating than caching in a map.
int slot = Arrays.asList(mChildProcessConnections).indexOf(connection);
if (slot == -1) {
Log.e(TAG, "Unable to find connection to free.");
assert false;
} else {
mChildProcessConnections[slot] = null;
assert !mFreeConnectionIndices.contains(slot);
mFreeConnectionIndices.add(slot);
Log.d(
TAG,
"Allocator freed a connection, name: %s, slot: %d",
mServiceClassName,
slot);
}
}
@VisibleForTesting
public boolean isFreeConnectionAvailable() {
return !mFreeConnectionIndices.isEmpty();
}
@Override
public int getNumberOfServices() {
return mChildProcessConnections.length;
}
@Override
public int allocatedConnectionsCountForTesting() {
return mChildProcessConnections.length - mFreeConnectionIndices.size();
}
public ChildProcessConnection getChildProcessConnectionAtSlotForTesting(int slotNumber) {
return mChildProcessConnections[slotNumber];
}
@Override
public boolean anyConnectionAllocated() {
return mFreeConnectionIndices.size() < mChildProcessConnections.length;
}
}
@VisibleForTesting
/* package */ static class VariableSizeAllocatorImpl extends ChildConnectionAllocator {
private final int mMaxAllocated;
private final ArraySet<ChildProcessConnection> mAllocatedConnections = new ArraySet<>();
private int mNextInstance;
// Note |serviceClassName| includes the service suffix.
private VariableSizeAllocatorImpl(
Handler launcherHandler,
Runnable freeSlotCallback,
String packageName,
String serviceClassName,
String fallbackServiceClassName,
boolean bindToCaller,
boolean bindAsExternalService,
boolean useStrongBinding,
int maxAllocated) {
super(
launcherHandler,
freeSlotCallback,
packageName,
serviceClassName,
fallbackServiceClassName,
bindToCaller,
bindAsExternalService,
useStrongBinding);
assert maxAllocated > 0;
mMaxAllocated = maxAllocated;
}
@Override
/* package */ ChildProcessConnection doAllocate(
Context context,
Bundle serviceBundle,
ChildProcessConnection.ServiceCallback serviceCallback) {
ChildProcessConnection connection = allocate(context, serviceBundle);
if (connection == null) return null;
mAllocatedConnections.add(connection);
connection.start(mUseStrongBinding, serviceCallback);
return connection;
}
/* package */ ChildProcessConnection tryAllocate(
Context context,
Bundle serviceBundle,
ChildProcessConnection.ServiceCallback serviceCallback) {
ChildProcessConnection connection = allocate(context, serviceBundle);
if (connection == null) return null;
boolean startResult = connection.tryStart(mUseStrongBinding, serviceCallback);
if (!startResult) return null;
mAllocatedConnections.add(connection);
return connection;
}
private ChildProcessConnection allocate(Context context, Bundle serviceBundle) {
if (mAllocatedConnections.size() >= mMaxAllocated) {
Log.w(TAG, "Ran out of UIDs to allocate.");
return null;
}
ComponentName serviceName = new ComponentName(mPackageName, mServiceClassName);
ComponentName fallbackServiceName = null;
if (mFallbackServiceClassName != null) {
fallbackServiceName = new ComponentName(mPackageName, mFallbackServiceClassName);
}
String instanceName = Integer.toString(mNextInstance);
mNextInstance++;
ChildProcessConnection connection =
mConnectionFactory.createConnection(
context,
serviceName,
fallbackServiceName,
mBindToCaller,
mBindAsExternalService,
serviceBundle,
instanceName);
assert connection != null;
return connection;
}
@Override
/* package */ void doFree(ChildProcessConnection connection) {
boolean result = mAllocatedConnections.remove(connection);
assert result;
}
/* package */ boolean wasConnectionAllocated(ChildProcessConnection connection) {
return mAllocatedConnections.contains(connection);
}
@Override
public int getNumberOfServices() {
return -1;
}
@Override
public int allocatedConnectionsCountForTesting() {
return mAllocatedConnections.size();
}
@Override
public boolean anyConnectionAllocated() {
return mAllocatedConnections.size() > 0;
}
}
/**
* Workaround allocator for Android 10 bug.
* Android 10 has a bug that UID used for non-primary user cannot be freed correctly,
* eventually exhausting the pool of UIDs for isolated services. There is a global pool of
* 1000 UIDs, and each app zygote has a smaller pool of 100; the bug appplies to both cases.
* The leaked UID in the app zygote pool are released when the zygote is killed; leaked UIDs in
* the global pool are released when the device is rebooted. So way to slightly delay until the
* device needs to be rebooted is to use up the app zygote pool first before using the
* non-zygote global pool.
*/
private static class Android10WorkaroundAllocatorImpl extends ChildConnectionAllocator {
private final VariableSizeAllocatorImpl mZygoteAllocator;
private final VariableSizeAllocatorImpl mNonZygoteAllocator;
private Android10WorkaroundAllocatorImpl(
Handler launcherHandler,
Runnable freeSlotCallback,
String packageName,
String serviceClassName,
boolean bindToCaller,
boolean bindAsExternalService,
boolean useStrongBinding,
int maxAllocated) {
super(
launcherHandler,
freeSlotCallback,
packageName,
serviceClassName,
null,
bindToCaller,
bindAsExternalService,
useStrongBinding);
mZygoteAllocator =
new VariableSizeAllocatorImpl(
launcherHandler,
freeSlotCallback,
packageName,
serviceClassName + ZYGOTE_SUFFIX,
null,
bindToCaller,
bindAsExternalService,
useStrongBinding,
maxAllocated);
mNonZygoteAllocator =
new VariableSizeAllocatorImpl(
launcherHandler,
freeSlotCallback,
packageName,
serviceClassName + NON_ZYGOTE_SUFFIX,
null,
bindToCaller,
bindAsExternalService,
useStrongBinding,
maxAllocated);
}
@Override
/* package */ ChildProcessConnection doAllocate(
Context context,
Bundle serviceBundle,
ChildProcessConnection.ServiceCallback serviceCallback) {
ChildProcessConnection connection =
mZygoteAllocator.tryAllocate(context, serviceBundle, serviceCallback);
if (connection != null) return connection;
return mNonZygoteAllocator.doAllocate(context, serviceBundle, serviceCallback);
}
@Override
/* package */ void doFree(ChildProcessConnection connection) {
if (mZygoteAllocator.wasConnectionAllocated(connection)) {
mZygoteAllocator.doFree(connection);
} else if (mNonZygoteAllocator.wasConnectionAllocated(connection)) {
mNonZygoteAllocator.doFree(connection);
} else {
assert false;
}
}
@Override
public int getNumberOfServices() {
return -1;
}
@Override
public int allocatedConnectionsCountForTesting() {
return mZygoteAllocator.allocatedConnectionsCountForTesting()
+ mNonZygoteAllocator.allocatedConnectionsCountForTesting();
}
@Override
public boolean anyConnectionAllocated() {
return mZygoteAllocator.anyConnectionAllocated()
|| mNonZygoteAllocator.anyConnectionAllocated();
}
@Override
public void setConnectionFactoryForTesting(ConnectionFactory connectionFactory) {
super.setConnectionFactoryForTesting(connectionFactory);
mZygoteAllocator.setConnectionFactoryForTesting(connectionFactory);
mNonZygoteAllocator.setConnectionFactoryForTesting(connectionFactory);
}
}
}
Codebase Browser
chromium