From 70e7011a076202c0063e6902449bcbe9de7a1140 Mon Sep 17 00:00:00 2001 From: Shai Barack Date: Tue, 5 Mar 2024 10:37:20 +0000 Subject: [PATCH] Do faster bitmask checks on NetworkCapabilities Allows compiler to turn some conditionals into constant expressions and to simply the machine code. Bug: 326744138 Change-Id: Ic0abed8c548986fe7ef1876bd1eb3e55ac6b8c10 --- .../src/android/net/NetworkCapabilities.java | 75 +++++++++-------- .../module/util/NetworkCapabilitiesUtils.java | 81 ++++++++++--------- 2 files changed, 80 insertions(+), 76 deletions(-) diff --git a/framework/src/android/net/NetworkCapabilities.java b/framework/src/android/net/NetworkCapabilities.java index f6ef75ea11..f7713a395c 100644 --- a/framework/src/android/net/NetworkCapabilities.java +++ b/framework/src/android/net/NetworkCapabilities.java @@ -749,22 +749,22 @@ public final class NetworkCapabilities implements Parcelable { * Network capabilities that are expected to be mutable, i.e., can change while a particular * network is connected. */ - private static final long MUTABLE_CAPABILITIES = BitUtils.packBitList( + private static final long MUTABLE_CAPABILITIES = // TRUSTED can change when user explicitly connects to an untrusted network in Settings. // http://b/18206275 - NET_CAPABILITY_TRUSTED, - NET_CAPABILITY_VALIDATED, - NET_CAPABILITY_CAPTIVE_PORTAL, - NET_CAPABILITY_NOT_ROAMING, - NET_CAPABILITY_FOREGROUND, - NET_CAPABILITY_NOT_CONGESTED, - NET_CAPABILITY_NOT_SUSPENDED, - NET_CAPABILITY_PARTIAL_CONNECTIVITY, - NET_CAPABILITY_TEMPORARILY_NOT_METERED, - NET_CAPABILITY_NOT_VCN_MANAGED, + (1L << NET_CAPABILITY_TRUSTED) | + (1L << NET_CAPABILITY_VALIDATED) | + (1L << NET_CAPABILITY_CAPTIVE_PORTAL) | + (1L << NET_CAPABILITY_NOT_ROAMING) | + (1L << NET_CAPABILITY_FOREGROUND) | + (1L << NET_CAPABILITY_NOT_CONGESTED) | + (1L << NET_CAPABILITY_NOT_SUSPENDED) | + (1L << NET_CAPABILITY_PARTIAL_CONNECTIVITY) | + (1L << NET_CAPABILITY_TEMPORARILY_NOT_METERED) | + (1L << NET_CAPABILITY_NOT_VCN_MANAGED) | // The value of NET_CAPABILITY_HEAD_UNIT is 32, which cannot use int to do bit shift, // otherwise there will be an overflow. Use long to do bit shift instead. - NET_CAPABILITY_HEAD_UNIT); + (1L << NET_CAPABILITY_HEAD_UNIT); /** * Network capabilities that are not allowed in NetworkRequests. This exists because the @@ -784,10 +784,10 @@ public final class NetworkCapabilities implements Parcelable { /** * Capabilities that are set by default when the object is constructed. */ - private static final long DEFAULT_CAPABILITIES = BitUtils.packBitList( - NET_CAPABILITY_NOT_RESTRICTED, - NET_CAPABILITY_TRUSTED, - NET_CAPABILITY_NOT_VPN); + private static final long DEFAULT_CAPABILITIES = + (1L << NET_CAPABILITY_NOT_RESTRICTED) | + (1L << NET_CAPABILITY_TRUSTED) | + (1L << NET_CAPABILITY_NOT_VPN); /** * Capabilities that are managed by ConnectivityService. @@ -795,11 +795,10 @@ public final class NetworkCapabilities implements Parcelable { */ @VisibleForTesting public static final long CONNECTIVITY_MANAGED_CAPABILITIES = - BitUtils.packBitList( - NET_CAPABILITY_VALIDATED, - NET_CAPABILITY_CAPTIVE_PORTAL, - NET_CAPABILITY_FOREGROUND, - NET_CAPABILITY_PARTIAL_CONNECTIVITY); + (1L << NET_CAPABILITY_VALIDATED) | + (1L << NET_CAPABILITY_CAPTIVE_PORTAL) | + (1L << NET_CAPABILITY_FOREGROUND) | + (1L << NET_CAPABILITY_PARTIAL_CONNECTIVITY); /** * Capabilities that are allowed for all test networks. This list must be set so that it is safe @@ -808,15 +807,14 @@ public final class NetworkCapabilities implements Parcelable { * IMS, SUPL, etc. */ private static final long TEST_NETWORKS_ALLOWED_CAPABILITIES = - BitUtils.packBitList( - NET_CAPABILITY_NOT_METERED, - NET_CAPABILITY_TEMPORARILY_NOT_METERED, - NET_CAPABILITY_NOT_RESTRICTED, - NET_CAPABILITY_NOT_VPN, - NET_CAPABILITY_NOT_ROAMING, - NET_CAPABILITY_NOT_CONGESTED, - NET_CAPABILITY_NOT_SUSPENDED, - NET_CAPABILITY_NOT_VCN_MANAGED); + (1L << NET_CAPABILITY_NOT_METERED) | + (1L << NET_CAPABILITY_TEMPORARILY_NOT_METERED) | + (1L << NET_CAPABILITY_NOT_RESTRICTED) | + (1L << NET_CAPABILITY_NOT_VPN) | + (1L << NET_CAPABILITY_NOT_ROAMING) | + (1L << NET_CAPABILITY_NOT_CONGESTED) | + (1L << NET_CAPABILITY_NOT_SUSPENDED) | + (1L << NET_CAPABILITY_NOT_VCN_MANAGED); /** * Extra allowed capabilities for test networks that do not have TRANSPORT_CELLULAR. Test @@ -824,7 +822,9 @@ public final class NetworkCapabilities implements Parcelable { * the risk of being used by running apps. */ private static final long TEST_NETWORKS_EXTRA_ALLOWED_CAPABILITIES_ON_NON_CELL = - BitUtils.packBitList(NET_CAPABILITY_CBS, NET_CAPABILITY_DUN, NET_CAPABILITY_RCS); + (1L << NET_CAPABILITY_CBS) | + (1L << NET_CAPABILITY_DUN) | + (1L << NET_CAPABILITY_RCS); /** * Adds the given capability to this {@code NetworkCapability} instance. @@ -1174,7 +1174,7 @@ public final class NetworkCapabilities implements Parcelable { * @hide */ public void maybeMarkCapabilitiesRestricted() { - if (NetworkCapabilitiesUtils.inferRestrictedCapability(this)) { + if (NetworkCapabilitiesUtils.inferRestrictedCapability(mNetworkCapabilities)) { removeCapability(NET_CAPABILITY_NOT_RESTRICTED); } } @@ -1368,12 +1368,11 @@ public final class NetworkCapabilities implements Parcelable { * Allowed transports on an unrestricted test network (in addition to TRANSPORT_TEST). */ private static final long UNRESTRICTED_TEST_NETWORKS_ALLOWED_TRANSPORTS = - BitUtils.packBitList( - TRANSPORT_TEST, - // Test eth networks are created with EthernetManager#setIncludeTestInterfaces - TRANSPORT_ETHERNET, - // Test VPN networks can be created but their UID ranges must be empty. - TRANSPORT_VPN); + (1L << TRANSPORT_TEST) | + // Test eth networks are created with EthernetManager#setIncludeTestInterfaces + (1L << TRANSPORT_ETHERNET) | + // Test VPN networks can be created but their UID ranges must be empty. + (1L << TRANSPORT_VPN); /** * Adds the given transport type to this {@code NetworkCapability} instance. diff --git a/staticlibs/framework/com/android/net/module/util/NetworkCapabilitiesUtils.java b/staticlibs/framework/com/android/net/module/util/NetworkCapabilitiesUtils.java index 54ce01ecbd..7fae5f6781 100644 --- a/staticlibs/framework/com/android/net/module/util/NetworkCapabilitiesUtils.java +++ b/staticlibs/framework/com/android/net/module/util/NetworkCapabilitiesUtils.java @@ -44,7 +44,7 @@ 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.net.module.util.BitUtils.packBitList; +import static com.android.net.module.util.BitUtils.packBits; import static com.android.net.module.util.BitUtils.unpackBits; import android.annotation.NonNull; @@ -88,41 +88,41 @@ public final class NetworkCapabilitiesUtils { * and {@code FORCE_RESTRICTED_CAPABILITIES}. */ @VisibleForTesting - public static final long RESTRICTED_CAPABILITIES = packBitList( - NET_CAPABILITY_BIP, - NET_CAPABILITY_CBS, - NET_CAPABILITY_DUN, - NET_CAPABILITY_EIMS, - NET_CAPABILITY_ENTERPRISE, - NET_CAPABILITY_FOTA, - NET_CAPABILITY_IA, - NET_CAPABILITY_IMS, - NET_CAPABILITY_MCX, - NET_CAPABILITY_RCS, - NET_CAPABILITY_VEHICLE_INTERNAL, - NET_CAPABILITY_VSIM, - NET_CAPABILITY_XCAP, - NET_CAPABILITY_MMTEL); + public static final long RESTRICTED_CAPABILITIES = + (1L << NET_CAPABILITY_BIP) | + (1L << NET_CAPABILITY_CBS) | + (1L << NET_CAPABILITY_DUN) | + (1L << NET_CAPABILITY_EIMS) | + (1L << NET_CAPABILITY_ENTERPRISE) | + (1L << NET_CAPABILITY_FOTA) | + (1L << NET_CAPABILITY_IA) | + (1L << NET_CAPABILITY_IMS) | + (1L << NET_CAPABILITY_MCX) | + (1L << NET_CAPABILITY_RCS) | + (1L << NET_CAPABILITY_VEHICLE_INTERNAL) | + (1L << NET_CAPABILITY_VSIM) | + (1L << NET_CAPABILITY_XCAP) | + (1L << NET_CAPABILITY_MMTEL); /** * Capabilities that force network to be restricted. * See {@code NetworkCapabilities#maybeMarkCapabilitiesRestricted}. */ - private static final long FORCE_RESTRICTED_CAPABILITIES = packBitList( - NET_CAPABILITY_ENTERPRISE, - NET_CAPABILITY_OEM_PAID, - NET_CAPABILITY_OEM_PRIVATE); + private static final long FORCE_RESTRICTED_CAPABILITIES = + (1L << NET_CAPABILITY_ENTERPRISE) | + (1L << NET_CAPABILITY_OEM_PAID) | + (1L << NET_CAPABILITY_OEM_PRIVATE); /** * Capabilities that suggest that a network is unrestricted. * See {@code NetworkCapabilities#maybeMarkCapabilitiesRestricted}. */ @VisibleForTesting - public static final long UNRESTRICTED_CAPABILITIES = packBitList( - NET_CAPABILITY_INTERNET, - NET_CAPABILITY_MMS, - NET_CAPABILITY_SUPL, - NET_CAPABILITY_WIFI_P2P); + public static final long UNRESTRICTED_CAPABILITIES = + (1L << NET_CAPABILITY_INTERNET) | + (1L << NET_CAPABILITY_MMS) | + (1L << NET_CAPABILITY_SUPL) | + (1L << NET_CAPABILITY_WIFI_P2P); /** * Get a transport that can be used to classify a network when displaying its info to users. @@ -158,28 +158,33 @@ public final class NetworkCapabilitiesUtils { * * @return {@code true} if the network should be restricted. */ - // TODO: Use packBits(nc.getCapabilities()) to check more easily using bit masks. public static boolean inferRestrictedCapability(NetworkCapabilities nc) { + return inferRestrictedCapability(packBits(nc.getCapabilities())); + } + + /** + * Infers that all the capabilities it provides are typically provided by restricted networks + * or not. + * + * @param capabilities see {@link NetworkCapabilities#getCapabilities()} + * + * @return {@code true} if the network should be restricted. + */ + public static boolean inferRestrictedCapability(long capabilities) { // Check if we have any capability that forces the network to be restricted. - for (int capability : unpackBits(FORCE_RESTRICTED_CAPABILITIES)) { - if (nc.hasCapability(capability)) { - return true; - } + if ((capabilities & FORCE_RESTRICTED_CAPABILITIES) != 0) { + return true; } // Verify there aren't any unrestricted capabilities. If there are we say // the whole thing is unrestricted unless it is forced to be restricted. - for (int capability : unpackBits(UNRESTRICTED_CAPABILITIES)) { - if (nc.hasCapability(capability)) { - return false; - } + if ((capabilities & UNRESTRICTED_CAPABILITIES) != 0) { + return false; } // Must have at least some restricted capabilities. - for (int capability : unpackBits(RESTRICTED_CAPABILITIES)) { - if (nc.hasCapability(capability)) { - return true; - } + if ((capabilities & RESTRICTED_CAPABILITIES) != 0) { + return true; } return false; }