739 lines
29 KiB
Java
739 lines
29 KiB
Java
/*
|
|
* Copyright (C) 2006 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 android.os;
|
|
|
|
import android.annotation.NonNull;
|
|
import android.annotation.Nullable;
|
|
import android.app.ActivityManager;
|
|
import android.app.AppOpsManager;
|
|
import android.util.Log;
|
|
import android.util.SparseIntArray;
|
|
|
|
import com.android.internal.annotations.GuardedBy;
|
|
import com.android.internal.os.BinderInternal;
|
|
|
|
import libcore.util.NativeAllocationRegistry;
|
|
|
|
import java.io.FileDescriptor;
|
|
import java.lang.ref.WeakReference;
|
|
import java.util.ArrayList;
|
|
import java.util.Arrays;
|
|
import java.util.Collections;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.concurrent.ExecutorService;
|
|
import java.util.concurrent.Executors;
|
|
import java.util.concurrent.TimeUnit;
|
|
|
|
/**
|
|
* Java proxy for a native IBinder object.
|
|
* Allocated and constructed by the native javaObjectforIBinder function. Never allocated
|
|
* directly from Java code.
|
|
*
|
|
* @hide
|
|
*/
|
|
public final class BinderProxy implements IBinder {
|
|
// See android_util_Binder.cpp for the native half of this.
|
|
|
|
// Assume the process-wide default value when created
|
|
volatile boolean mWarnOnBlocking = Binder.sWarnOnBlocking;
|
|
|
|
private static volatile Binder.ProxyTransactListener sTransactListener = null;
|
|
|
|
private static class BinderProxyMapSizeException extends AssertionError {
|
|
BinderProxyMapSizeException(String s) {
|
|
super(s);
|
|
}
|
|
};
|
|
|
|
/**
|
|
* @see {@link Binder#setProxyTransactListener(listener)}.
|
|
*/
|
|
public static void setTransactListener(@Nullable Binder.ProxyTransactListener listener) {
|
|
sTransactListener = listener;
|
|
}
|
|
|
|
/*
|
|
* Map from longs to BinderProxy, retaining only a WeakReference to the BinderProxies.
|
|
* We roll our own only because we need to lazily remove WeakReferences during accesses
|
|
* to avoid accumulating junk WeakReference objects. WeakHashMap isn't easily usable
|
|
* because we want weak values, not keys.
|
|
* Our hash table is never resized, but the number of entries is unlimited;
|
|
* performance degrades as occupancy increases significantly past MAIN_INDEX_SIZE.
|
|
* Not thread-safe. Client ensures there's a single access at a time.
|
|
*/
|
|
private static final class ProxyMap {
|
|
private static final int LOG_MAIN_INDEX_SIZE = 8;
|
|
private static final int MAIN_INDEX_SIZE = 1 << LOG_MAIN_INDEX_SIZE;
|
|
private static final int MAIN_INDEX_MASK = MAIN_INDEX_SIZE - 1;
|
|
/**
|
|
* We will throw a BinderProxyMapSizeException if the number of map entries
|
|
* exceeds:
|
|
*/
|
|
private static final int CRASH_AT_SIZE = 25_000;
|
|
|
|
/**
|
|
* We next warn when we exceed this bucket size.
|
|
*/
|
|
private int mWarnBucketSize = 20;
|
|
|
|
/**
|
|
* Increment mWarnBucketSize by WARN_INCREMENT each time we warn.
|
|
*/
|
|
private static final int WARN_INCREMENT = 10;
|
|
|
|
/**
|
|
* Hash function tailored to native pointers.
|
|
* Returns a value < MAIN_INDEX_SIZE.
|
|
*/
|
|
private static int hash(long arg) {
|
|
return ((int) ((arg >> 2) ^ (arg >> (2 + LOG_MAIN_INDEX_SIZE)))) & MAIN_INDEX_MASK;
|
|
}
|
|
|
|
/**
|
|
* Return the total number of pairs in the map.
|
|
*/
|
|
private int size() {
|
|
int size = 0;
|
|
for (ArrayList<WeakReference<BinderProxy>> a : mMainIndexValues) {
|
|
if (a != null) {
|
|
size += a.size();
|
|
}
|
|
}
|
|
return size;
|
|
}
|
|
|
|
/**
|
|
* Return the total number of pairs in the map containing values that have
|
|
* not been cleared. More expensive than the above size function.
|
|
*/
|
|
private int unclearedSize() {
|
|
int size = 0;
|
|
for (ArrayList<WeakReference<BinderProxy>> a : mMainIndexValues) {
|
|
if (a != null) {
|
|
for (WeakReference<BinderProxy> ref : a) {
|
|
if (!ref.refersTo(null)) {
|
|
++size;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return size;
|
|
}
|
|
|
|
/**
|
|
* Remove ith entry from the hash bucket indicated by hash.
|
|
*/
|
|
private void remove(int hash, int index) {
|
|
Long[] keyArray = mMainIndexKeys[hash];
|
|
ArrayList<WeakReference<BinderProxy>> valueArray = mMainIndexValues[hash];
|
|
int size = valueArray.size(); // KeyArray may have extra elements.
|
|
// Move last entry into empty slot, and truncate at end.
|
|
if (index != size - 1) {
|
|
keyArray[index] = keyArray[size - 1];
|
|
valueArray.set(index, valueArray.get(size - 1));
|
|
}
|
|
valueArray.remove(size - 1);
|
|
// Just leave key array entry; it's unused. We only trust the valueArray size.
|
|
}
|
|
|
|
/**
|
|
* Look up the supplied key. If we have a non-cleared entry for it, return it.
|
|
*/
|
|
BinderProxy get(long key) {
|
|
int myHash = hash(key);
|
|
Long[] keyArray = mMainIndexKeys[myHash];
|
|
if (keyArray == null) {
|
|
return null;
|
|
}
|
|
ArrayList<WeakReference<BinderProxy>> valueArray = mMainIndexValues[myHash];
|
|
int bucketSize = valueArray.size();
|
|
for (int i = 0; i < bucketSize; ++i) {
|
|
long foundKey = keyArray[i];
|
|
if (key == foundKey) {
|
|
WeakReference<BinderProxy> wr = valueArray.get(i);
|
|
BinderProxy bp = wr.get();
|
|
if (bp != null) {
|
|
return bp;
|
|
} else {
|
|
remove(myHash, i);
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private int mRandom; // A counter used to generate a "random" index. World's 2nd worst RNG.
|
|
|
|
/**
|
|
* Add the key-value pair to the map.
|
|
* Requires that the indicated key is not already in the map.
|
|
*/
|
|
void set(long key, @NonNull BinderProxy value) {
|
|
int myHash = hash(key);
|
|
ArrayList<WeakReference<BinderProxy>> valueArray = mMainIndexValues[myHash];
|
|
if (valueArray == null) {
|
|
valueArray = mMainIndexValues[myHash] = new ArrayList<>();
|
|
mMainIndexKeys[myHash] = new Long[1];
|
|
}
|
|
int size = valueArray.size();
|
|
WeakReference<BinderProxy> newWr = new WeakReference<>(value);
|
|
// First look for a cleared reference.
|
|
// This ensures that ArrayList size is bounded by the maximum occupancy of
|
|
// that bucket.
|
|
for (int i = 0; i < size; ++i) {
|
|
if (valueArray.get(i).refersTo(null)) {
|
|
valueArray.set(i, newWr);
|
|
Long[] keyArray = mMainIndexKeys[myHash];
|
|
keyArray[i] = key;
|
|
if (i < size - 1) {
|
|
// "Randomly" check one of the remaining entries in [i+1, size), so that
|
|
// needlessly long buckets are eventually pruned.
|
|
int rnd = Math.floorMod(++mRandom, size - (i + 1));
|
|
if (valueArray.get(i + 1 + rnd).refersTo(null)) {
|
|
remove(myHash, i + 1 + rnd);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
valueArray.add(size, newWr);
|
|
Long[] keyArray = mMainIndexKeys[myHash];
|
|
if (keyArray.length == size) {
|
|
// size >= 1, since we initially allocated one element
|
|
Long[] newArray = new Long[size + size / 2 + 2];
|
|
System.arraycopy(keyArray, 0, newArray, 0, size);
|
|
newArray[size] = key;
|
|
mMainIndexKeys[myHash] = newArray;
|
|
} else {
|
|
keyArray[size] = key;
|
|
}
|
|
if (size >= mWarnBucketSize) {
|
|
final int totalSize = size();
|
|
Log.v(Binder.TAG, "BinderProxy map growth! bucket size = " + size
|
|
+ " total = " + totalSize);
|
|
mWarnBucketSize += WARN_INCREMENT;
|
|
if (totalSize >= CRASH_AT_SIZE) {
|
|
// Use the number of uncleared entries to determine whether we should
|
|
// really report a histogram and crash. We don't want to fundamentally
|
|
// change behavior for a debuggable process, so we GC only if we are
|
|
// about to crash.
|
|
final int totalUnclearedSize = unclearedSize();
|
|
if (totalUnclearedSize >= CRASH_AT_SIZE) {
|
|
dumpProxyInterfaceCounts();
|
|
dumpPerUidProxyCounts();
|
|
Runtime.getRuntime().gc();
|
|
throw new BinderProxyMapSizeException(
|
|
"Binder ProxyMap has too many entries: "
|
|
+ totalSize + " (total), " + totalUnclearedSize + " (uncleared), "
|
|
+ unclearedSize() + " (uncleared after GC). BinderProxy leak?");
|
|
} else if (totalSize > 3 * totalUnclearedSize / 2) {
|
|
Log.v(Binder.TAG, "BinderProxy map has many cleared entries: "
|
|
+ (totalSize - totalUnclearedSize) + " of " + totalSize
|
|
+ " are cleared");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private InterfaceCount[] getSortedInterfaceCounts(int maxToReturn) {
|
|
if (maxToReturn < 0) {
|
|
throw new IllegalArgumentException("negative interface count");
|
|
}
|
|
|
|
Map<String, Integer> counts = new HashMap<>();
|
|
final ArrayList<WeakReference<BinderProxy>> proxiesToQuery =
|
|
new ArrayList<WeakReference<BinderProxy>>();
|
|
synchronized (sProxyMap) {
|
|
for (ArrayList<WeakReference<BinderProxy>> a : mMainIndexValues) {
|
|
if (a != null) {
|
|
proxiesToQuery.addAll(a);
|
|
}
|
|
}
|
|
}
|
|
// For gathering this debug output, we're making synchronous binder calls
|
|
// out of system_server to all processes hosting binder objects it holds a reference to;
|
|
// since some of those processes might be frozen, we don't want to block here
|
|
// forever. Disable the freezer.
|
|
try {
|
|
ActivityManager.getService().enableAppFreezer(false);
|
|
} catch (RemoteException e) {
|
|
Log.e(Binder.TAG, "RemoteException while disabling app freezer");
|
|
}
|
|
|
|
// We run the dump on a separate thread, because there are known cases where
|
|
// a process overrides getInterfaceDescriptor() and somehow blocks on it, causing
|
|
// the calling thread (usually AMS) to hit the watchdog.
|
|
// Do the dumping on a separate thread instead, and give up after a while.
|
|
ExecutorService executorService = Executors.newSingleThreadExecutor();
|
|
executorService.submit(() -> {
|
|
for (WeakReference<BinderProxy> weakRef : proxiesToQuery) {
|
|
BinderProxy bp = weakRef.get();
|
|
String key;
|
|
if (bp == null) {
|
|
key = "<cleared weak-ref>";
|
|
} else {
|
|
try {
|
|
key = bp.getInterfaceDescriptor();
|
|
if ((key == null || key.isEmpty()) && !bp.isBinderAlive()) {
|
|
key = "<proxy to dead node>";
|
|
}
|
|
} catch (Throwable t) {
|
|
key = "<exception during getDescriptor>";
|
|
}
|
|
}
|
|
Integer i = counts.get(key);
|
|
if (i == null) {
|
|
counts.put(key, 1);
|
|
} else {
|
|
counts.put(key, i + 1);
|
|
}
|
|
}
|
|
});
|
|
|
|
try {
|
|
executorService.shutdown();
|
|
boolean dumpDone = executorService.awaitTermination(20, TimeUnit.SECONDS);
|
|
if (!dumpDone) {
|
|
Log.e(Binder.TAG, "Failed to complete binder proxy dump,"
|
|
+ " dumping what we have so far.");
|
|
}
|
|
} catch (InterruptedException e) {
|
|
// Ignore
|
|
}
|
|
try {
|
|
ActivityManager.getService().enableAppFreezer(true);
|
|
} catch (RemoteException e) {
|
|
Log.e(Binder.TAG, "RemoteException while re-enabling app freezer");
|
|
}
|
|
Map.Entry<String, Integer>[] sorted = counts.entrySet().toArray(
|
|
new Map.Entry[counts.size()]);
|
|
|
|
Arrays.sort(sorted, (Map.Entry<String, Integer> a, Map.Entry<String, Integer> b)
|
|
-> b.getValue().compareTo(a.getValue()));
|
|
|
|
int returnCount = Math.min(maxToReturn, sorted.length);
|
|
InterfaceCount[] ifaceCounts = new InterfaceCount[returnCount];
|
|
for (int i = 0; i < returnCount; i++) {
|
|
ifaceCounts[i] = new InterfaceCount(sorted[i].getKey(), sorted[i].getValue());
|
|
}
|
|
return ifaceCounts;
|
|
}
|
|
|
|
static final int MAX_NUM_INTERFACES_TO_DUMP = 10;
|
|
|
|
/**
|
|
* Dump a histogram to the logcat. Used to diagnose abnormally large proxy maps.
|
|
*/
|
|
private void dumpProxyInterfaceCounts() {
|
|
final InterfaceCount[] sorted = getSortedInterfaceCounts(MAX_NUM_INTERFACES_TO_DUMP);
|
|
|
|
Log.v(Binder.TAG, "BinderProxy descriptor histogram "
|
|
+ "(top " + Integer.toString(MAX_NUM_INTERFACES_TO_DUMP) + "):");
|
|
for (int i = 0; i < sorted.length; i++) {
|
|
Log.v(Binder.TAG, " #" + (i + 1) + ": " + sorted[i]);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Dump per uid binder proxy counts to the logcat.
|
|
*/
|
|
private void dumpPerUidProxyCounts() {
|
|
SparseIntArray counts = BinderInternal.nGetBinderProxyPerUidCounts();
|
|
if (counts.size() == 0) return;
|
|
Log.d(Binder.TAG, "Per Uid Binder Proxy Counts:");
|
|
for (int i = 0; i < counts.size(); i++) {
|
|
final int uid = counts.keyAt(i);
|
|
final int binderCount = counts.valueAt(i);
|
|
Log.d(Binder.TAG, "UID : " + uid + " count = " + binderCount);
|
|
}
|
|
}
|
|
|
|
// Corresponding ArrayLists in the following two arrays always have the same size.
|
|
// They contain no empty entries. However WeakReferences in the values ArrayLists
|
|
// may have been cleared.
|
|
|
|
// mMainIndexKeys[i][j] corresponds to mMainIndexValues[i].get(j) .
|
|
// The values ArrayList has the proper size(), the corresponding keys array
|
|
// is always at least the same size, but may be larger.
|
|
// If either a particular keys array, or the corresponding values ArrayList
|
|
// are null, then they both are.
|
|
private final Long[][] mMainIndexKeys = new Long[MAIN_INDEX_SIZE][];
|
|
private final ArrayList<WeakReference<BinderProxy>>[] mMainIndexValues =
|
|
new ArrayList[MAIN_INDEX_SIZE];
|
|
}
|
|
|
|
@GuardedBy("sProxyMap")
|
|
private static final ProxyMap sProxyMap = new ProxyMap();
|
|
|
|
/**
|
|
* Simple pair-value class to store number of binder proxy interfaces live in this process.
|
|
*/
|
|
public static final class InterfaceCount {
|
|
private final String mInterfaceName;
|
|
private final int mCount;
|
|
|
|
InterfaceCount(String interfaceName, int count) {
|
|
mInterfaceName = interfaceName;
|
|
mCount = count;
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
return mInterfaceName + " x" + Integer.toString(mCount);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Get a sorted array with entries mapping proxy interface names to the number
|
|
* of live proxies with those names.
|
|
*
|
|
* @param num maximum number of proxy interface counts to return. Use
|
|
* Integer.MAX_VALUE to retrieve all
|
|
* @hide
|
|
*/
|
|
public static InterfaceCount[] getSortedInterfaceCounts(int num) {
|
|
return sProxyMap.getSortedInterfaceCounts(num);
|
|
}
|
|
|
|
/**
|
|
* Returns the number of binder proxies held in this process.
|
|
* @return number of binder proxies in this process
|
|
*/
|
|
public static int getProxyCount() {
|
|
synchronized (sProxyMap) {
|
|
return sProxyMap.size();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Dump proxy debug information.
|
|
*
|
|
* @hide
|
|
*/
|
|
public static void dumpProxyDebugInfo() {
|
|
if (Build.IS_DEBUGGABLE) {
|
|
sProxyMap.dumpProxyInterfaceCounts();
|
|
sProxyMap.dumpPerUidProxyCounts();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Return a BinderProxy for IBinder.
|
|
* If we previously returned a BinderProxy bp for the same iBinder, and bp is still
|
|
* in use, then we return the same bp.
|
|
*
|
|
* @param nativeData C++ pointer to (possibly still empty) BinderProxyNativeData.
|
|
* Takes ownership of nativeData iff <result>.mNativeData == nativeData, or if
|
|
* we exit via an exception. If neither applies, it's the callers responsibility to
|
|
* recycle nativeData.
|
|
* @param iBinder C++ pointer to IBinder. Does not take ownership of referenced object.
|
|
*/
|
|
private static BinderProxy getInstance(long nativeData, long iBinder) {
|
|
BinderProxy result;
|
|
synchronized (sProxyMap) {
|
|
try {
|
|
result = sProxyMap.get(iBinder);
|
|
if (result != null) {
|
|
return result;
|
|
}
|
|
result = new BinderProxy(nativeData);
|
|
} catch (Throwable e) {
|
|
// We're throwing an exception (probably OOME); don't drop nativeData.
|
|
NativeAllocationRegistry.applyFreeFunction(NoImagePreloadHolder.sNativeFinalizer,
|
|
nativeData);
|
|
throw e;
|
|
}
|
|
NoImagePreloadHolder.sRegistry.registerNativeAllocation(result, nativeData);
|
|
// The registry now owns nativeData, even if registration threw an exception.
|
|
sProxyMap.set(iBinder, result);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private BinderProxy(long nativeData) {
|
|
mNativeData = nativeData;
|
|
}
|
|
|
|
/**
|
|
* Guestimate of native memory associated with a BinderProxy.
|
|
* This includes the underlying IBinder, associated DeathRecipientList, and KeyedVector
|
|
* that points back to us. We guess high since it includes a GlobalRef, which
|
|
* may be in short supply.
|
|
*/
|
|
private static final int NATIVE_ALLOCATION_SIZE = 1000;
|
|
|
|
// Use a Holder to allow static initialization of BinderProxy in the boot image, and
|
|
// to avoid some initialization ordering issues.
|
|
private static class NoImagePreloadHolder {
|
|
public static final long sNativeFinalizer = getNativeFinalizer();
|
|
public static final NativeAllocationRegistry sRegistry = new NativeAllocationRegistry(
|
|
BinderProxy.class.getClassLoader(), sNativeFinalizer, NATIVE_ALLOCATION_SIZE);
|
|
}
|
|
|
|
/**
|
|
* @return false if the hosting process is gone, otherwise whatever the remote returns
|
|
*/
|
|
public native boolean pingBinder();
|
|
|
|
/**
|
|
* @return false if the hosting process is gone
|
|
*/
|
|
public native boolean isBinderAlive();
|
|
|
|
/**
|
|
* Retrieve a local interface - always null in case of a proxy
|
|
*/
|
|
public IInterface queryLocalInterface(String descriptor) {
|
|
return null;
|
|
}
|
|
|
|
/** @hide */
|
|
@Override
|
|
public native @Nullable IBinder getExtension() throws RemoteException;
|
|
|
|
/**
|
|
* Perform a binder transaction on a proxy.
|
|
*
|
|
* @param code The action to perform. This should
|
|
* be a number between {@link #FIRST_CALL_TRANSACTION} and
|
|
* {@link #LAST_CALL_TRANSACTION}.
|
|
* @param data Marshalled data to send to the target. Must not be null.
|
|
* If you are not sending any data, you must create an empty Parcel
|
|
* that is given here.
|
|
* @param reply Marshalled data to be received from the target. May be
|
|
* null if you are not interested in the return value.
|
|
* @param flags Additional operation flags. Either 0 for a normal
|
|
* RPC, or {@link #FLAG_ONEWAY} for a one-way RPC.
|
|
*
|
|
* @return
|
|
* @throws RemoteException
|
|
*/
|
|
public boolean transact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
|
|
Binder.checkParcel(this, code, data, "Unreasonably large binder buffer");
|
|
|
|
boolean warnOnBlocking = mWarnOnBlocking; // Cache it to reduce volatile access.
|
|
|
|
if (warnOnBlocking && ((flags & FLAG_ONEWAY) == 0)
|
|
&& Binder.sWarnOnBlockingOnCurrentThread.get()) {
|
|
|
|
// For now, avoid spamming the log by disabling after we've logged
|
|
// about this interface at least once
|
|
mWarnOnBlocking = false;
|
|
warnOnBlocking = false;
|
|
|
|
if (Build.IS_USERDEBUG || Build.IS_ENG) {
|
|
// Log this as a WTF on userdebug and eng builds.
|
|
Log.wtf(Binder.TAG,
|
|
"Outgoing transactions from this process must be FLAG_ONEWAY",
|
|
new Throwable());
|
|
} else {
|
|
Log.w(Binder.TAG,
|
|
"Outgoing transactions from this process must be FLAG_ONEWAY",
|
|
new Throwable());
|
|
}
|
|
}
|
|
|
|
final boolean tracingEnabled = Binder.isStackTrackingEnabled();
|
|
if (tracingEnabled) {
|
|
final Throwable tr = new Throwable();
|
|
Binder.getTransactionTracker().addTrace(tr);
|
|
StackTraceElement stackTraceElement = tr.getStackTrace()[1];
|
|
Trace.traceBegin(Trace.TRACE_TAG_ALWAYS,
|
|
stackTraceElement.getClassName() + "." + stackTraceElement.getMethodName());
|
|
}
|
|
|
|
// Make sure the listener won't change while processing a transaction.
|
|
final Binder.ProxyTransactListener transactListener = sTransactListener;
|
|
Object session = null;
|
|
|
|
if (transactListener != null) {
|
|
final int origWorkSourceUid = Binder.getCallingWorkSourceUid();
|
|
session = transactListener.onTransactStarted(this, code, flags);
|
|
|
|
// Allow the listener to update the work source uid. We need to update the request
|
|
// header if the uid is updated.
|
|
final int updatedWorkSourceUid = Binder.getCallingWorkSourceUid();
|
|
if (origWorkSourceUid != updatedWorkSourceUid) {
|
|
data.replaceCallingWorkSourceUid(updatedWorkSourceUid);
|
|
}
|
|
}
|
|
|
|
final AppOpsManager.PausedNotedAppOpsCollection prevCollection =
|
|
AppOpsManager.pauseNotedAppOpsCollection();
|
|
|
|
if ((flags & FLAG_ONEWAY) == 0 && AppOpsManager.isListeningForOpNoted()) {
|
|
flags |= FLAG_COLLECT_NOTED_APP_OPS;
|
|
}
|
|
|
|
try {
|
|
final boolean result = transactNative(code, data, reply, flags);
|
|
|
|
if (reply != null && !warnOnBlocking) {
|
|
reply.addFlags(Parcel.FLAG_IS_REPLY_FROM_BLOCKING_ALLOWED_OBJECT);
|
|
}
|
|
|
|
return result;
|
|
} finally {
|
|
AppOpsManager.resumeNotedAppOpsCollection(prevCollection);
|
|
|
|
if (transactListener != null) {
|
|
transactListener.onTransactEnded(session);
|
|
}
|
|
|
|
if (tracingEnabled) {
|
|
Trace.traceEnd(Trace.TRACE_TAG_ALWAYS);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Returns the native free function */
|
|
private static native long getNativeFinalizer();
|
|
/**
|
|
* See {@link IBinder#getInterfaceDescriptor()}
|
|
*/
|
|
public native String getInterfaceDescriptor() throws RemoteException;
|
|
|
|
/**
|
|
* Native implementation of transact() for proxies
|
|
*/
|
|
public native boolean transactNative(int code, Parcel data, Parcel reply,
|
|
int flags) throws RemoteException;
|
|
|
|
/* This list is to hold strong reference to the death recipients that are waiting for the death
|
|
* of binder that this proxy references. Previously, the death recipients were strongy
|
|
* referenced from JNI, but that can cause memory leak (b/298374304) when the application has a
|
|
* strong reference from the death recipient to the proxy object. The JNI reference is now weak.
|
|
* And this strong reference is to keep death recipients at least until the proxy is GC'ed. */
|
|
private List<DeathRecipient> mDeathRecipients = Collections.synchronizedList(new ArrayList<>());
|
|
|
|
/**
|
|
* See {@link IBinder#linkToDeath(DeathRecipient, int)}
|
|
*/
|
|
public void linkToDeath(DeathRecipient recipient, int flags)
|
|
throws RemoteException {
|
|
linkToDeathNative(recipient, flags);
|
|
mDeathRecipients.add(recipient);
|
|
}
|
|
|
|
/**
|
|
* See {@link IBinder#unlinkToDeath}
|
|
*/
|
|
public boolean unlinkToDeath(DeathRecipient recipient, int flags) {
|
|
mDeathRecipients.remove(recipient);
|
|
return unlinkToDeathNative(recipient, flags);
|
|
}
|
|
|
|
private native void linkToDeathNative(DeathRecipient recipient, int flags)
|
|
throws RemoteException;
|
|
|
|
private native boolean unlinkToDeathNative(DeathRecipient recipient, int flags);
|
|
|
|
/**
|
|
* Perform a dump on the remote object
|
|
*
|
|
* @param fd The raw file descriptor that the dump is being sent to.
|
|
* @param args additional arguments to the dump request.
|
|
* @throws RemoteException
|
|
*/
|
|
public void dump(FileDescriptor fd, String[] args) throws RemoteException {
|
|
Parcel data = Parcel.obtain();
|
|
Parcel reply = Parcel.obtain();
|
|
data.writeFileDescriptor(fd);
|
|
data.writeStringArray(args);
|
|
try {
|
|
transact(DUMP_TRANSACTION, data, reply, 0);
|
|
reply.readException();
|
|
} finally {
|
|
data.recycle();
|
|
reply.recycle();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Perform an asynchronous dump on the remote object
|
|
*
|
|
* @param fd The raw file descriptor that the dump is being sent to.
|
|
* @param args additional arguments to the dump request.
|
|
* @throws RemoteException
|
|
*/
|
|
public void dumpAsync(FileDescriptor fd, String[] args) throws RemoteException {
|
|
Parcel data = Parcel.obtain();
|
|
Parcel reply = Parcel.obtain();
|
|
data.writeFileDescriptor(fd);
|
|
data.writeStringArray(args);
|
|
try {
|
|
transact(DUMP_TRANSACTION, data, reply, FLAG_ONEWAY);
|
|
} finally {
|
|
data.recycle();
|
|
reply.recycle();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* See {@link IBinder#shellCommand(FileDescriptor, FileDescriptor, FileDescriptor,
|
|
* String[], ShellCallback, ResultReceiver)}
|
|
*
|
|
* @param in The raw file descriptor that an input data stream can be read from.
|
|
* @param out The raw file descriptor that normal command messages should be written to.
|
|
* @param err The raw file descriptor that command error messages should be written to.
|
|
* @param args Command-line arguments.
|
|
* @param callback Optional callback to the caller's shell to perform operations in it.
|
|
* @param resultReceiver Called when the command has finished executing, with the result code.
|
|
* @throws RemoteException
|
|
*/
|
|
public void shellCommand(FileDescriptor in, FileDescriptor out, FileDescriptor err,
|
|
String[] args, ShellCallback callback,
|
|
ResultReceiver resultReceiver) throws RemoteException {
|
|
Parcel data = Parcel.obtain();
|
|
Parcel reply = Parcel.obtain();
|
|
data.writeFileDescriptor(in);
|
|
data.writeFileDescriptor(out);
|
|
data.writeFileDescriptor(err);
|
|
data.writeStringArray(args);
|
|
ShellCallback.writeToParcel(callback, data);
|
|
resultReceiver.writeToParcel(data, 0);
|
|
try {
|
|
transact(SHELL_COMMAND_TRANSACTION, data, reply, 0);
|
|
reply.readException();
|
|
} finally {
|
|
data.recycle();
|
|
reply.recycle();
|
|
}
|
|
}
|
|
|
|
private static void sendDeathNotice(DeathRecipient recipient, IBinder binderProxy) {
|
|
if (false) {
|
|
Log.v("JavaBinder", "sendDeathNotice to " + recipient + " for " + binderProxy);
|
|
}
|
|
try {
|
|
recipient.binderDied(binderProxy);
|
|
} catch (RuntimeException exc) {
|
|
Log.w("BinderNative", "Uncaught exception from death notification",
|
|
exc);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* C++ pointer to BinderProxyNativeData. That consists of strong pointers to the
|
|
* native IBinder object, and a DeathRecipientList.
|
|
*/
|
|
private final long mNativeData;
|
|
}
|