Merge "Merge changes Id0d536ff,I4fcd0ad7 into oc-dev am: 0e8090b10e" into oc-dev-plus-aosp (562e577b) · Commits · e / os / android_frameworks_base

core/java/android/net/metrics/ConnectStats.java

+35 −50

Original line number	Diff line number	Diff line
		@@ -16,53 +16,47 @@

		package android.net.metrics;

		import android.net.NetworkCapabilities;
		import android.system.OsConstants;
		import android.util.IntArray;
		import android.util.SparseIntArray;
		import com.android.internal.util.BitUtils;
		import com.android.internal.util.TokenBucket;
		import com.android.server.connectivity.metrics.nano.IpConnectivityLogClass.ConnectStatistics;
		import com.android.server.connectivity.metrics.nano.IpConnectivityLogClass.Pair;

		/**
		* A class that aggregates connect() statistics and helps build
		* IpConnectivityLogClass.ConnectStatistics instances.
		*
		* A class that aggregates connect() statistics.
		* {@hide}
		*/
		public class ConnectStats {
		private final static int EALREADY = OsConstants.EALREADY;
		private final static int EINPROGRESS = OsConstants.EINPROGRESS;

		/** Network id of the network associated with the event, or 0 if unspecified. */
		public final int netId;
		/** Transports of the network associated with the event, as defined in NetworkCapabilities. */
		public final long transports;
		/** How many events resulted in a given errno. */
		private final SparseIntArray mErrnos = new SparseIntArray();
		/** Latencies of blocking connects. TODO: add non-blocking connects latencies. */
		private final IntArray mLatencies = new IntArray();
		public final SparseIntArray errnos = new SparseIntArray();
		/** Latencies of successful blocking connects. TODO: add non-blocking connects latencies. */
		public final IntArray latencies = new IntArray();
		/** TokenBucket for rate limiting latency recording. */
		private final TokenBucket mLatencyTb;
		public final TokenBucket mLatencyTb;
		/** Maximum number of latency values recorded. */
		private final int mMaxLatencyRecords;
		public final int mMaxLatencyRecords;
		/** Total count of successful connects. */
		private int mConnectCount = 0;
		public int connectCount = 0;
		/** Total count of successful connects done in blocking mode. */
		private int mConnectBlockingCount = 0;
		public int connectBlockingCount = 0;
		/** Total count of successful connects with IPv6 socket address. */
		private int mIpv6ConnectCount = 0;
		public int ipv6ConnectCount = 0;

		public ConnectStats(TokenBucket tb, int maxLatencyRecords) {
		public ConnectStats(int netId, long transports, TokenBucket tb, int maxLatencyRecords) {
		this.netId = netId;
		this.transports = transports;
		mLatencyTb = tb;
		mMaxLatencyRecords = maxLatencyRecords;
		}

		public ConnectStatistics toProto() {
		ConnectStatistics stats = new ConnectStatistics();
		stats.connectCount = mConnectCount;
		stats.connectBlockingCount = mConnectBlockingCount;
		stats.ipv6AddrCount = mIpv6ConnectCount;
		stats.latenciesMs = mLatencies.toArray();
		stats.errnosCounters = toPairArrays(mErrnos);
		return stats;
		}

		public void addEvent(int errno, int latencyMs, String ipAddr) {
		if (isSuccess(errno)) {
		countConnect(errno, ipAddr);
		@@ -73,12 +67,12 @@ public class ConnectStats {
		}

		private void countConnect(int errno, String ipAddr) {
		mConnectCount++;
		connectCount++;
		if (!isNonBlocking(errno)) {
		mConnectBlockingCount++;
		connectBlockingCount++;
		}
		if (isIPv6(ipAddr)) {
		mIpv6ConnectCount++;
		ipv6ConnectCount++;
		}
		}

		@@ -91,16 +85,16 @@ public class ConnectStats {
		// Rate limited
		return;
		}
		if (mLatencies.size() >= mMaxLatencyRecords) {
		if (latencies.size() >= mMaxLatencyRecords) {
		// Hard limit the total number of latency measurements.
		return;
		}
		mLatencies.add(ms);
		latencies.add(ms);
		}

		private void countError(int errno) {
		final int newcount = mErrnos.get(errno, 0) + 1;
		mErrnos.put(errno, newcount);
		final int newcount = errnos.get(errno, 0) + 1;
		errnos.put(errno, newcount);
		}

		private static boolean isSuccess(int errno) {
		@@ -117,27 +111,18 @@ public class ConnectStats {
		return ipAddr.contains(":");
		}

		private static Pair[] toPairArrays(SparseIntArray counts) {
		final int s = counts.size();
		Pair[] pairs = new Pair[s];
		for (int i = 0; i < s; i++) {
		Pair p = new Pair();
		p.key = counts.keyAt(i);
		p.value = counts.valueAt(i);
		pairs[i] = p;
		}
		return pairs;
		}

		@Override
		public String toString() {
		StringBuilder builder = new StringBuilder("ConnectStats(")
		.append(String.format("%d success, ", mConnectCount))
		.append(String.format("%d blocking, ", mConnectBlockingCount))
		.append(String.format("%d IPv6 dst", mIpv6ConnectCount));
		for (int i = 0; i < mErrnos.size(); i++) {
		String errno = OsConstants.errnoName(mErrnos.keyAt(i));
		int count = mErrnos.valueAt(i);
		StringBuilder builder = new StringBuilder("ConnectStats(").append(netId).append(", ");
		for (int t : BitUtils.unpackBits(transports)) {
		builder.append(NetworkCapabilities.transportNameOf(t)).append(", ");
		}
		builder.append(String.format("%d success, ", connectCount));
		builder.append(String.format("%d blocking, ", connectBlockingCount));
		builder.append(String.format("%d IPv6 dst", ipv6ConnectCount));
		for (int i = 0; i < errnos.size(); i++) {
		String errno = OsConstants.errnoName(errnos.keyAt(i));
		int count = errnos.valueAt(i);
		builder.append(String.format(", %s: %d", errno, count));
		}
		return builder.append(")").toString();

core/java/android/net/metrics/DnsEvent.java

+47 −44

Original line number	Diff line number	Diff line
		@@ -16,67 +16,70 @@

		package android.net.metrics;

		import android.os.Parcel;
		import android.os.Parcelable;
		import android.net.NetworkCapabilities;
		import java.util.Arrays;
		import com.android.internal.util.BitUtils;

		/**
		* A DNS event recorded by NetdEventListenerService.
		* {@hide}
		*/
		final public class DnsEvent implements Parcelable {
		public final int netId;
		final public class DnsEvent {

		private static final int SIZE_LIMIT = 20000;

		// The event type is currently only 1 or 2, so we store it as a byte.
		public final byte[] eventTypes;
		// Network id of the network associated with the event, or 0 if unspecified.
		public final int netId;
		// Transports of the network associated with the event, as defined in NetworkCapabilities.
		// It is the caller responsability to ensure the value of transports does not change between
		// calls to addResult.
		public final long transports;
		// The number of DNS queries recorded. Queries are stored in the structure-of-array style where
		// the eventTypes, returnCodes, and latenciesMs arrays have the same length and the i-th event
		// is spread across the three array at position i.
		public int eventCount;
		// The types of DNS queries as defined in INetdEventListener.
		public byte[] eventTypes;
		// Current getaddrinfo codes go from 1 to EAI_MAX = 15. gethostbyname returns errno, but there
		// are fewer than 255 errno values. So we store the result code in a byte as well.
		public final byte[] returnCodes;
		// The latency is an integer because a) short arrays aren't parcelable and b) a short can only
		// store a maximum latency of 32757 or 65535 ms, which is too short for pathologically slow
		// queries.
		public final int[] latenciesMs;
		public byte[] returnCodes;
		// Latencies in milliseconds of queries, stored as ints.
		public int[] latenciesMs;

		public DnsEvent(int netId, byte[] eventTypes, byte[] returnCodes, int[] latenciesMs) {
		public DnsEvent(int netId, long transports, int initialCapacity) {
		this.netId = netId;
		this.eventTypes = eventTypes;
		this.returnCodes = returnCodes;
		this.latenciesMs = latenciesMs;
		this.transports = transports;
		eventTypes = new byte[initialCapacity];
		returnCodes = new byte[initialCapacity];
		latenciesMs = new int[initialCapacity];
		}

		private DnsEvent(Parcel in) {
		this.netId = in.readInt();
		this.eventTypes = in.createByteArray();
		this.returnCodes = in.createByteArray();
		this.latenciesMs = in.createIntArray();
		public void addResult(byte eventType, byte returnCode, int latencyMs) {
		if (eventCount >= SIZE_LIMIT) {
		// TODO: implement better rate limiting that does not biases metrics.
		return;
		}

		@Override
		public void writeToParcel(Parcel out, int flags) {
		out.writeInt(netId);
		out.writeByteArray(eventTypes);
		out.writeByteArray(returnCodes);
		out.writeIntArray(latenciesMs);
		if (eventCount == eventTypes.length) {
		resize((int) (1.4 * eventCount));
		}

		@Override
		public int describeContents() {
		return 0;
		eventTypes[eventCount] = eventType;
		returnCodes[eventCount] = returnCode;
		latenciesMs[eventCount] = latencyMs;
		eventCount++;
		}

		@Override
		public String toString() {
		return String.format("DnsEvent(%d, %d events)", netId, eventTypes.length);
		public void resize(int newLength) {
		eventTypes = Arrays.copyOf(eventTypes, newLength);
		returnCodes = Arrays.copyOf(returnCodes, newLength);
		latenciesMs = Arrays.copyOf(latenciesMs, newLength);
		}

		public static final Parcelable.Creator<DnsEvent> CREATOR = new Parcelable.Creator<DnsEvent>() {
		@Override
		public DnsEvent createFromParcel(Parcel in) {
		return new DnsEvent(in);
		public String toString() {
		StringBuilder builder = new StringBuilder("DnsEvent(").append(netId).append(", ");
		for (int t : BitUtils.unpackBits(transports)) {
		builder.append(NetworkCapabilities.transportNameOf(t)).append(", ");
		}

		@Override
		public DnsEvent[] newArray(int size) {
		return new DnsEvent[size];
		return builder.append(eventCount).append(" events)").toString();
		}
		};
		}

services/core/java/com/android/server/connectivity/IpConnectivityEventBuilder.java

+57 −26

Original line number	Diff line number	Diff line
		@@ -23,9 +23,6 @@ import static android.net.NetworkCapabilities.TRANSPORT_ETHERNET;
		import static android.net.NetworkCapabilities.TRANSPORT_VPN;
		import static android.net.NetworkCapabilities.TRANSPORT_WIFI;
		import static android.net.NetworkCapabilities.TRANSPORT_WIFI_AWARE;
		import static com.android.server.connectivity.metrics.nano.IpConnectivityLogClass.IpConnectivityEvent;
		import static com.android.server.connectivity.metrics.nano.IpConnectivityLogClass.IpConnectivityLog;
		import static com.android.server.connectivity.metrics.nano.IpConnectivityLogClass.NetworkId;

		import android.net.ConnectivityMetricsEvent;
		import android.net.metrics.ApfProgramEvent;
		@@ -34,6 +31,7 @@ import android.net.metrics.DefaultNetworkEvent;
		import android.net.metrics.DhcpClientEvent;
		import android.net.metrics.DhcpErrorEvent;
		import android.net.metrics.DnsEvent;
		import android.net.metrics.ConnectStats;
		import android.net.metrics.IpManagerEvent;
		import android.net.metrics.IpReachabilityEvent;
		import android.net.metrics.NetworkEvent;
		@@ -41,7 +39,12 @@ import android.net.metrics.RaEvent;
		import android.net.metrics.ValidationProbeEvent;
		import android.os.Parcelable;
		import android.util.SparseArray;
		import android.util.SparseIntArray;
		import com.android.server.connectivity.metrics.nano.IpConnectivityLogClass;
		import com.android.server.connectivity.metrics.nano.IpConnectivityLogClass.IpConnectivityEvent;
		import com.android.server.connectivity.metrics.nano.IpConnectivityLogClass.IpConnectivityLog;
		import com.android.server.connectivity.metrics.nano.IpConnectivityLogClass.NetworkId;
		import com.android.server.connectivity.metrics.nano.IpConnectivityLogClass.Pair;
		import java.io.IOException;
		import java.util.ArrayList;
		import java.util.List;
		@@ -77,20 +80,51 @@ final public class IpConnectivityEventBuilder {
		}

		public static IpConnectivityEvent toProto(ConnectivityMetricsEvent ev) {
		final IpConnectivityEvent out = new IpConnectivityEvent();
		final IpConnectivityEvent out = buildEvent(ev.netId, ev.transports, ev.ifname);
		out.timeMs = ev.timestamp;
		if (!setEvent(out, ev.data)) {
		return null;
		}
		out.timeMs = ev.timestamp;
		out.networkId = ev.netId;
		out.transports = ev.transports;
		if (ev.ifname != null) {
		out.ifName = ev.ifname;
		return out;
		}

		public static IpConnectivityEvent toProto(ConnectStats in) {
		IpConnectivityLogClass.ConnectStatistics stats =
		new IpConnectivityLogClass.ConnectStatistics();
		stats.connectCount = in.connectCount;
		stats.connectBlockingCount = in.connectBlockingCount;
		stats.ipv6AddrCount = in.ipv6ConnectCount;
		stats.latenciesMs = in.latencies.toArray();
		stats.errnosCounters = toPairArray(in.errnos);
		final IpConnectivityEvent out = buildEvent(in.netId, in.transports, null);
		out.setConnectStatistics(stats);
		return out;
		}
		inferLinkLayer(out);


		public static IpConnectivityEvent toProto(DnsEvent in) {
		IpConnectivityLogClass.DNSLookupBatch dnsLookupBatch =
		new IpConnectivityLogClass.DNSLookupBatch();
		in.resize(in.eventCount);
		dnsLookupBatch.eventTypes = bytesToInts(in.eventTypes);
		dnsLookupBatch.returnCodes = bytesToInts(in.returnCodes);
		dnsLookupBatch.latenciesMs = in.latenciesMs;
		final IpConnectivityEvent out = buildEvent(in.netId, in.transports, null);
		out.setDnsLookupBatch(dnsLookupBatch);
		return out;
		}

		private static IpConnectivityEvent buildEvent(int netId, long transports, String ifname) {
		final IpConnectivityEvent ev = new IpConnectivityEvent();
		ev.networkId = netId;
		ev.transports = transports;
		if (ifname != null) {
		ev.ifName = ifname;
		}
		inferLinkLayer(ev);
		return ev;
		}

		private static boolean setEvent(IpConnectivityEvent out, Parcelable in) {
		if (in instanceof DhcpErrorEvent) {
		setDhcpErrorEvent(out, (DhcpErrorEvent) in);
		@@ -102,11 +136,6 @@ final public class IpConnectivityEventBuilder {
		return true;
		}

		if (in instanceof DnsEvent) {
		setDnsEvent(out, (DnsEvent) in);
		return true;
		}

		if (in instanceof IpManagerEvent) {
		setIpManagerEvent(out, (IpManagerEvent) in);
		return true;
		@@ -163,16 +192,6 @@ final public class IpConnectivityEventBuilder {
		out.setDhcpEvent(dhcpEvent);
		}

		private static void setDnsEvent(IpConnectivityEvent out, DnsEvent in) {
		IpConnectivityLogClass.DNSLookupBatch dnsLookupBatch =
		new IpConnectivityLogClass.DNSLookupBatch();
		dnsLookupBatch.networkId = netIdOf(in.netId);
		dnsLookupBatch.eventTypes = bytesToInts(in.eventTypes);
		dnsLookupBatch.returnCodes = bytesToInts(in.returnCodes);
		dnsLookupBatch.latenciesMs = in.latenciesMs;
		out.setDnsLookupBatch(dnsLookupBatch);
		}

		private static void setIpManagerEvent(IpConnectivityEvent out, IpManagerEvent in) {
		IpConnectivityLogClass.IpProvisioningEvent ipProvisioningEvent =
		new IpConnectivityLogClass.IpProvisioningEvent();
		@@ -268,6 +287,18 @@ final public class IpConnectivityEventBuilder {
		return out;
		}

		private static Pair[] toPairArray(SparseIntArray counts) {
		final int s = counts.size();
		Pair[] pairs = new Pair[s];
		for (int i = 0; i < s; i++) {
		Pair p = new Pair();
		p.key = counts.keyAt(i);
		p.value = counts.valueAt(i);
		pairs[i] = p;
		}
		return pairs;
		}

		private static NetworkId netIdOf(int netid) {
		final NetworkId ni = new NetworkId();
		ni.networkId = netid;

services/core/java/com/android/server/connectivity/IpConnectivityMetrics.java

+2 −1

Original line number	Diff line number	Diff line
		@@ -76,7 +76,8 @@ final public class IpConnectivityMetrics extends SystemService {

		@VisibleForTesting
		public final Impl impl = new Impl();
		private NetdEventListenerService mNetdListener;
		@VisibleForTesting
		NetdEventListenerService mNetdListener;

		@GuardedBy("mLock")
		private ArrayList<ConnectivityMetricsEvent> mBuffer;

services/core/java/com/android/server/connectivity/NetdEventListenerService.java

+63 −111

File changed.

Preview size limit exceeded, changes collapsed.