diff --git a/Tethering/apishim/31/com/android/networkstack/tethering/apishim/api31/BpfCoordinatorShimImpl.java b/Tethering/apishim/31/com/android/networkstack/tethering/apishim/api31/BpfCoordinatorShimImpl.java
index 4ebf914..78fa533 100644
--- a/Tethering/apishim/31/com/android/networkstack/tethering/apishim/api31/BpfCoordinatorShimImpl.java
+++ b/Tethering/apishim/31/com/android/networkstack/tethering/apishim/api31/BpfCoordinatorShimImpl.java
@@ -30,8 +30,8 @@
 import com.android.networkstack.tethering.BpfCoordinator.Dependencies;
 import com.android.networkstack.tethering.BpfCoordinator.Ipv6ForwardingRule;
 import com.android.networkstack.tethering.BpfMap;
-import com.android.networkstack.tethering.TetherIngressKey;
-import com.android.networkstack.tethering.TetherIngressValue;
+import com.android.networkstack.tethering.TetherDownstream6Key;
+import com.android.networkstack.tethering.TetherDownstream6Value;
 import com.android.networkstack.tethering.TetherLimitKey;
 import com.android.networkstack.tethering.TetherLimitValue;
 import com.android.networkstack.tethering.TetherStatsKey;
@@ -57,7 +57,7 @@
     // BPF map of ingress queueing discipline which pre-processes the packets by the IPv6
     // forwarding rules.
     @Nullable
-    private final BpfMap<TetherIngressKey, TetherIngressValue> mBpfIngressMap;
+    private final BpfMap<TetherDownstream6Key, TetherDownstream6Value> mBpfDownstream6Map;
 
     // BPF map of tethering statistics of the upstream interface since tethering startup.
     @Nullable
@@ -69,25 +69,25 @@
 
     public BpfCoordinatorShimImpl(@NonNull final Dependencies deps) {
         mLog = deps.getSharedLog().forSubComponent(TAG);
-        mBpfIngressMap = deps.getBpfIngressMap();
+        mBpfDownstream6Map = deps.getBpfIngressMap();
         mBpfStatsMap = deps.getBpfStatsMap();
         mBpfLimitMap = deps.getBpfLimitMap();
     }
 
     @Override
     public boolean isInitialized() {
-        return mBpfIngressMap != null && mBpfStatsMap != null  && mBpfLimitMap != null;
+        return mBpfDownstream6Map != null && mBpfStatsMap != null  && mBpfLimitMap != null;
     }
 
     @Override
     public boolean tetherOffloadRuleAdd(@NonNull final Ipv6ForwardingRule rule) {
         if (!isInitialized()) return false;
 
-        final TetherIngressKey key = rule.makeTetherIngressKey();
-        final TetherIngressValue value = rule.makeTetherIngressValue();
+        final TetherDownstream6Key key = rule.makeTetherDownstream6Key();
+        final TetherDownstream6Value value = rule.makeTetherDownstream6Value();
 
         try {
-            mBpfIngressMap.updateEntry(key, value);
+            mBpfDownstream6Map.updateEntry(key, value);
         } catch (ErrnoException e) {
             mLog.e("Could not update entry: ", e);
             return false;
@@ -101,7 +101,7 @@
         if (!isInitialized()) return false;
 
         try {
-            mBpfIngressMap.deleteEntry(rule.makeTetherIngressKey());
+            mBpfDownstream6Map.deleteEntry(rule.makeTetherDownstream6Key());
         } catch (ErrnoException e) {
             // Silent if the rule did not exist.
             if (e.errno != OsConstants.ENOENT) {
@@ -234,8 +234,8 @@
 
     @Override
     public String toString() {
-        return "mBpfIngressMap{"
-                + (mBpfIngressMap != null ? "initialized" : "not initialized") + "}, "
+        return "mBpfDownstream6Map{"
+                + (mBpfDownstream6Map != null ? "initialized" : "not initialized") + "}, "
                 + "mBpfStatsMap{"
                 + (mBpfStatsMap != null ? "initialized" : "not initialized") + "}, "
                 + "mBpfLimitMap{"
diff --git a/Tethering/bpf_progs/offload.c b/Tethering/bpf_progs/offload.c
index c66bb5c..cb1c0e5 100644
--- a/Tethering/bpf_progs/offload.c
+++ b/Tethering/bpf_progs/offload.c
@@ -24,7 +24,7 @@
 #include "bpf_net_helpers.h"
 #include "netdbpf/bpf_shared.h"
 
-DEFINE_BPF_MAP_GRW(tether_ingress_map, HASH, TetherIngressKey, TetherIngressValue, 64,
+DEFINE_BPF_MAP_GRW(tether_downstream6_map, HASH, TetherDownstream6Key, TetherDownstream6Value, 64,
                    AID_NETWORK_STACK)
 
 // Tethering stats, indexed by upstream interface.
@@ -63,12 +63,12 @@
         (src32 & htonl(0xe0000000)) != htonl(0x20000000))    // 2000::/3 Global Unicast
         return TC_ACT_OK;
 
-    TetherIngressKey k = {
+    TetherDownstream6Key k = {
             .iif = skb->ifindex,
             .neigh6 = ip6->daddr,
     };
 
-    TetherIngressValue* v = bpf_tether_ingress_map_lookup_elem(&k);
+    TetherDownstream6Value* v = bpf_tether_downstream6_map_lookup_elem(&k);
 
     // If we don't find any offload information then simply let the core stack handle it...
     if (!v) return TC_ACT_OK;
@@ -162,8 +162,8 @@
     return bpf_redirect(v->oif, 0 /* this is effectively BPF_F_EGRESS */);
 }
 
-DEFINE_BPF_PROG("schedcls/ingress/tether_ether", AID_ROOT, AID_ROOT,
-                sched_cls_ingress_tether_ether)
+DEFINE_BPF_PROG("schedcls/tether_downstream6_ether", AID_ROOT, AID_ROOT,
+                sched_cls_tether_downstream6_ether)
 (struct __sk_buff* skb) {
     return do_forward(skb, true);
 }
@@ -181,15 +181,15 @@
 // and thus a 5.4 kernel always supports this.
 //
 // Hence, this mandatory (must load successfully) implementation for 5.4+ kernels:
-DEFINE_BPF_PROG_KVER("schedcls/ingress/tether_rawip$5_4", AID_ROOT, AID_ROOT,
-                     sched_cls_ingress_tether_rawip_5_4, KVER(5, 4, 0))
+DEFINE_BPF_PROG_KVER("schedcls/tether_downstream6_rawip$5_4", AID_ROOT, AID_ROOT,
+                     sched_cls_tether_downstream6_rawip_5_4, KVER(5, 4, 0))
 (struct __sk_buff* skb) {
     return do_forward(skb, false);
 }
 
 // and this identical optional (may fail to load) implementation for [4.14..5.4) patched kernels:
-DEFINE_OPTIONAL_BPF_PROG_KVER_RANGE("schedcls/ingress/tether_rawip$4_14", AID_ROOT, AID_ROOT,
-                                    sched_cls_ingress_tether_rawip_4_14, KVER(4, 14, 0),
+DEFINE_OPTIONAL_BPF_PROG_KVER_RANGE("schedcls/tether_downstream6_rawip$4_14", AID_ROOT, AID_ROOT,
+                                    sched_cls_tether_downstream6_rawip_4_14, KVER(4, 14, 0),
                                     KVER(5, 4, 0))
 (struct __sk_buff* skb) {
     return do_forward(skb, false);
@@ -198,8 +198,8 @@
 // and define a no-op stub for [4.9,4.14) and unpatched [4.14,5.4) kernels.
 // (if the above real 4.14+ program loaded successfully, then bpfloader will have already pinned
 // it at the same location this one would be pinned at and will thus skip loading this stub)
-DEFINE_BPF_PROG_KVER_RANGE("schedcls/ingress/tether_rawip$stub", AID_ROOT, AID_ROOT,
-                           sched_cls_ingress_tether_rawip_stub, KVER_NONE, KVER(5, 4, 0))
+DEFINE_BPF_PROG_KVER_RANGE("schedcls/tether_downstream6_rawip$stub", AID_ROOT, AID_ROOT,
+                           sched_cls_tether_downstream6_rawip_stub, KVER_NONE, KVER(5, 4, 0))
 (struct __sk_buff* skb) {
     return TC_ACT_OK;
 }
diff --git a/Tethering/bpf_progs/test.c b/Tethering/bpf_progs/test.c
index eeaaa62..4dd33e6 100644
--- a/Tethering/bpf_progs/test.c
+++ b/Tethering/bpf_progs/test.c
@@ -23,7 +23,7 @@
 #include "netdbpf/bpf_shared.h"
 
 // Used only by TetheringPrivilegedTests, not by production code.
-DEFINE_BPF_MAP_GRW(tether_ingress_map, HASH, TetherIngressKey, TetherIngressValue, 16,
+DEFINE_BPF_MAP_GRW(tether_downstream6_map, HASH, TetherDownstream6Key, TetherDownstream6Value, 16,
                    AID_NETWORK_STACK)
 
 DEFINE_BPF_PROG_KVER("xdp/drop_ipv4_udp_ether", AID_ROOT, AID_ROOT,
diff --git a/Tethering/src/com/android/networkstack/tethering/BpfCoordinator.java b/Tethering/src/com/android/networkstack/tethering/BpfCoordinator.java
index 64ac37c..fac5725 100644
--- a/Tethering/src/com/android/networkstack/tethering/BpfCoordinator.java
+++ b/Tethering/src/com/android/networkstack/tethering/BpfCoordinator.java
@@ -74,7 +74,7 @@
     private static final String TAG = BpfCoordinator.class.getSimpleName();
     private static final int DUMP_TIMEOUT_MS = 10_000;
     private static final String TETHER_INGRESS_FS_PATH =
-            "/sys/fs/bpf/map_offload_tether_ingress_map";
+            "/sys/fs/bpf/map_offload_tether_downstream6_map";
     private static final String TETHER_STATS_MAP_PATH =
             "/sys/fs/bpf/map_offload_tether_stats_map";
     private static final String TETHER_LIMIT_MAP_PATH =
@@ -191,10 +191,10 @@
         }
 
         /** Get ingress BPF map. */
-        @Nullable public BpfMap<TetherIngressKey, TetherIngressValue> getBpfIngressMap() {
+        @Nullable public BpfMap<TetherDownstream6Key, TetherDownstream6Value> getBpfIngressMap() {
             try {
                 return new BpfMap<>(TETHER_INGRESS_FS_PATH,
-                    BpfMap.BPF_F_RDWR, TetherIngressKey.class, TetherIngressValue.class);
+                    BpfMap.BPF_F_RDWR, TetherDownstream6Key.class, TetherDownstream6Value.class);
             } catch (ErrnoException e) {
                 Log.e(TAG, "Cannot create ingress map: " + e);
                 return null;
@@ -554,19 +554,19 @@
         }
 
         /**
-         * Return a TetherIngressKey object built from the rule.
+         * Return a TetherDownstream6Key object built from the rule.
          */
         @NonNull
-        public TetherIngressKey makeTetherIngressKey() {
-            return new TetherIngressKey(upstreamIfindex, address.getAddress());
+        public TetherDownstream6Key makeTetherDownstream6Key() {
+            return new TetherDownstream6Key(upstreamIfindex, address.getAddress());
         }
 
         /**
-         * Return a TetherIngressValue object built from the rule.
+         * Return a TetherDownstream6Value object built from the rule.
          */
         @NonNull
-        public TetherIngressValue makeTetherIngressValue() {
-            return new TetherIngressValue(downstreamIfindex, dstMac, srcMac, ETH_P_IPV6,
+        public TetherDownstream6Value makeTetherDownstream6Value() {
+            return new TetherDownstream6Value(downstreamIfindex, dstMac, srcMac, ETH_P_IPV6,
                     NetworkStackConstants.ETHER_MTU);
         }
 
diff --git a/Tethering/src/com/android/networkstack/tethering/TetherIngressKey.java b/Tethering/src/com/android/networkstack/tethering/TetherDownstream6Key.java
similarity index 86%
rename from Tethering/src/com/android/networkstack/tethering/TetherIngressKey.java
rename to Tethering/src/com/android/networkstack/tethering/TetherDownstream6Key.java
index 78683c5..3860cba 100644
--- a/Tethering/src/com/android/networkstack/tethering/TetherIngressKey.java
+++ b/Tethering/src/com/android/networkstack/tethering/TetherDownstream6Key.java
@@ -26,14 +26,14 @@
 import java.util.Arrays;
 
 /** The key of BpfMap which is used for bpf offload. */
-public class TetherIngressKey extends Struct {
+public class TetherDownstream6Key extends Struct {
     @Field(order = 0, type = Type.U32)
     public final long iif; // The input interface index.
 
     @Field(order = 1, type = Type.ByteArray, arraysize = 16)
     public final byte[] neigh6; // The destination IPv6 address.
 
-    public TetherIngressKey(final long iif, final byte[] neigh6) {
+    public TetherDownstream6Key(final long iif, final byte[] neigh6) {
         try {
             final Inet6Address unused = (Inet6Address) InetAddress.getByAddress(neigh6);
         } catch (ClassCastException | UnknownHostException e) {
@@ -48,9 +48,9 @@
     public boolean equals(Object obj) {
         if (this == obj) return true;
 
-        if (!(obj instanceof TetherIngressKey)) return false;
+        if (!(obj instanceof TetherDownstream6Key)) return false;
 
-        final TetherIngressKey that = (TetherIngressKey) obj;
+        final TetherDownstream6Key that = (TetherDownstream6Key) obj;
 
         return iif == that.iif && Arrays.equals(neigh6, that.neigh6);
     }
@@ -66,7 +66,7 @@
             return String.format("iif: %d, neigh: %s", iif, Inet6Address.getByAddress(neigh6));
         } catch (UnknownHostException e) {
             // Should not happen because construtor already verify neigh6.
-            throw new IllegalStateException("Invalid TetherIngressKey");
+            throw new IllegalStateException("Invalid TetherDownstream6Key");
         }
     }
 }
diff --git a/Tethering/src/com/android/networkstack/tethering/TetherIngressValue.java b/Tethering/src/com/android/networkstack/tethering/TetherDownstream6Value.java
similarity index 89%
rename from Tethering/src/com/android/networkstack/tethering/TetherIngressValue.java
rename to Tethering/src/com/android/networkstack/tethering/TetherDownstream6Value.java
index e2116fc..a56269d 100644
--- a/Tethering/src/com/android/networkstack/tethering/TetherIngressValue.java
+++ b/Tethering/src/com/android/networkstack/tethering/TetherDownstream6Value.java
@@ -27,7 +27,7 @@
 import java.util.Objects;
 
 /** The value of BpfMap which is used for bpf offload. */
-public class TetherIngressValue extends Struct {
+public class TetherDownstream6Value extends Struct {
     @Field(order = 0, type = Type.U32)
     public final long oif; // The output interface index.
 
@@ -42,7 +42,7 @@
     @Field(order = 4, type = Type.U16)
     public final int pmtu; // The maximum L3 output path/route mtu.
 
-    public TetherIngressValue(final long oif, @NonNull final MacAddress ethDstMac,
+    public TetherDownstream6Value(final long oif, @NonNull final MacAddress ethDstMac,
             @NonNull final MacAddress ethSrcMac, final int ethProto, final int pmtu) {
         Objects.requireNonNull(ethSrcMac);
         Objects.requireNonNull(ethDstMac);
@@ -58,9 +58,9 @@
     public boolean equals(Object obj) {
         if (this == obj) return true;
 
-        if (!(obj instanceof TetherIngressValue)) return false;
+        if (!(obj instanceof TetherDownstream6Value)) return false;
 
-        final TetherIngressValue that = (TetherIngressValue) obj;
+        final TetherDownstream6Value that = (TetherDownstream6Value) obj;
 
         return oif == that.oif && ethDstMac.equals(that.ethDstMac)
                 && ethSrcMac.equals(that.ethSrcMac) && ethProto == that.ethProto
diff --git a/Tethering/tests/privileged/src/com/android/networkstack/tethering/BpfMapTest.java b/Tethering/tests/privileged/src/com/android/networkstack/tethering/BpfMapTest.java
index dba8fab..bff204b 100644
--- a/Tethering/tests/privileged/src/com/android/networkstack/tethering/BpfMapTest.java
+++ b/Tethering/tests/privileged/src/com/android/networkstack/tethering/BpfMapTest.java
@@ -52,9 +52,9 @@
     // Sync from packages/modules/Connectivity/Tethering/bpf_progs/offload.c.
     private static final int TEST_MAP_SIZE = 16;
     private static final String TETHER_INGRESS_FS_PATH =
-            "/sys/fs/bpf/tethering/map_test_tether_ingress_map";
+            "/sys/fs/bpf/tethering/map_test_tether_downstream6_map";
 
-    private ArrayMap<TetherIngressKey, TetherIngressValue> mTestData;
+    private ArrayMap<TetherDownstream6Key, TetherDownstream6Value> mTestData;
 
     @BeforeClass
     public static void setupOnce() {
@@ -70,15 +70,15 @@
         cleanTestMap();
 
         mTestData = new ArrayMap<>();
-        mTestData.put(createTetherIngressKey(101, "2001:db8::1"),
-                createTetherIngressValue(11, "00:00:00:00:00:0a", "11:11:11:00:00:0b", ETH_P_IPV6,
-                1280));
-        mTestData.put(createTetherIngressKey(102, "2001:db8::2"),
-                createTetherIngressValue(22, "00:00:00:00:00:0c", "22:22:22:00:00:0d", ETH_P_IPV6,
-                1400));
-        mTestData.put(createTetherIngressKey(103, "2001:db8::3"),
-                createTetherIngressValue(33, "00:00:00:00:00:0e", "33:33:33:00:00:0f", ETH_P_IPV6,
-                1500));
+        mTestData.put(createTetherDownstream6Key(101, "2001:db8::1"),
+                createTetherDownstream6Value(11, "00:00:00:00:00:0a", "11:11:11:00:00:0b",
+                ETH_P_IPV6, 1280));
+        mTestData.put(createTetherDownstream6Key(102, "2001:db8::2"),
+                createTetherDownstream6Value(22, "00:00:00:00:00:0c", "22:22:22:00:00:0d",
+                ETH_P_IPV6, 1400));
+        mTestData.put(createTetherDownstream6Key(103, "2001:db8::3"),
+                createTetherDownstream6Value(33, "00:00:00:00:00:0e", "33:33:33:00:00:0f",
+                ETH_P_IPV6, 1500));
     }
 
     @After
@@ -86,14 +86,14 @@
         cleanTestMap();
     }
 
-    private BpfMap<TetherIngressKey, TetherIngressValue> getTestMap() throws Exception {
+    private BpfMap<TetherDownstream6Key, TetherDownstream6Value> getTestMap() throws Exception {
         return new BpfMap<>(
                 TETHER_INGRESS_FS_PATH, BpfMap.BPF_F_RDWR,
-                TetherIngressKey.class, TetherIngressValue.class);
+                TetherDownstream6Key.class, TetherDownstream6Value.class);
     }
 
     private void cleanTestMap() throws Exception {
-        try (BpfMap<TetherIngressKey, TetherIngressValue> bpfMap = getTestMap()) {
+        try (BpfMap<TetherDownstream6Key, TetherDownstream6Value> bpfMap = getTestMap()) {
             bpfMap.forEach((key, value) -> {
                 try {
                     assertTrue(bpfMap.deleteEntry(key));
@@ -105,24 +105,25 @@
         }
     }
 
-    private TetherIngressKey createTetherIngressKey(long iif, String address) throws Exception {
+    private TetherDownstream6Key createTetherDownstream6Key(long iif, String address)
+            throws Exception {
         final InetAddress ipv6Address = InetAddress.getByName(address);
 
-        return new TetherIngressKey(iif, ipv6Address.getAddress());
+        return new TetherDownstream6Key(iif, ipv6Address.getAddress());
     }
 
-    private TetherIngressValue createTetherIngressValue(long oif, String src, String dst, int proto,
-            int pmtu) throws Exception {
+    private TetherDownstream6Value createTetherDownstream6Value(long oif, String src, String dst,
+            int proto, int pmtu) throws Exception {
         final MacAddress srcMac = MacAddress.fromString(src);
         final MacAddress dstMac = MacAddress.fromString(dst);
 
-        return new TetherIngressValue(oif, dstMac, srcMac, proto, pmtu);
+        return new TetherDownstream6Value(oif, dstMac, srcMac, proto, pmtu);
     }
 
     @Test
     public void testGetFd() throws Exception {
         try (BpfMap readOnlyMap = new BpfMap<>(TETHER_INGRESS_FS_PATH, BpfMap.BPF_F_RDONLY,
-                TetherIngressKey.class, TetherIngressValue.class)) {
+                TetherDownstream6Key.class, TetherDownstream6Value.class)) {
             assertNotNull(readOnlyMap);
             try {
                 readOnlyMap.insertEntry(mTestData.keyAt(0), mTestData.valueAt(0));
@@ -132,7 +133,7 @@
             }
         }
         try (BpfMap writeOnlyMap = new BpfMap<>(TETHER_INGRESS_FS_PATH, BpfMap.BPF_F_WRONLY,
-                TetherIngressKey.class, TetherIngressValue.class)) {
+                TetherDownstream6Key.class, TetherDownstream6Value.class)) {
             assertNotNull(writeOnlyMap);
             try {
                 writeOnlyMap.getFirstKey();
@@ -142,14 +143,14 @@
             }
         }
         try (BpfMap readWriteMap = new BpfMap<>(TETHER_INGRESS_FS_PATH, BpfMap.BPF_F_RDWR,
-                TetherIngressKey.class, TetherIngressValue.class)) {
+                TetherDownstream6Key.class, TetherDownstream6Value.class)) {
             assertNotNull(readWriteMap);
         }
     }
 
     @Test
     public void testGetFirstKey() throws Exception {
-        try (BpfMap<TetherIngressKey, TetherIngressValue> bpfMap = getTestMap()) {
+        try (BpfMap<TetherDownstream6Key, TetherDownstream6Value> bpfMap = getTestMap()) {
             // getFirstKey on an empty map returns null.
             assertFalse(bpfMap.containsKey(mTestData.keyAt(0)));
             assertNull(bpfMap.getFirstKey());
@@ -163,9 +164,10 @@
 
     @Test
     public void testGetNextKey() throws Exception {
-        try (BpfMap<TetherIngressKey, TetherIngressValue> bpfMap = getTestMap()) {
+        try (BpfMap<TetherDownstream6Key, TetherDownstream6Value> bpfMap = getTestMap()) {
             // [1] If the passed-in key is not found on empty map, return null.
-            final TetherIngressKey nonexistentKey = createTetherIngressKey(1234, "2001:db8::10");
+            final TetherDownstream6Key nonexistentKey =
+                    createTetherDownstream6Key(1234, "2001:db8::10");
             assertNull(bpfMap.getNextKey(nonexistentKey));
 
             // [2] If the passed-in key is null on empty map, throw NullPointerException.
@@ -175,13 +177,14 @@
             } catch (NullPointerException expected) { }
 
             // The BPF map has one entry now.
-            final ArrayMap<TetherIngressKey, TetherIngressValue> resultMap = new ArrayMap<>();
+            final ArrayMap<TetherDownstream6Key, TetherDownstream6Value> resultMap =
+                    new ArrayMap<>();
             bpfMap.insertEntry(mTestData.keyAt(0), mTestData.valueAt(0));
             resultMap.put(mTestData.keyAt(0), mTestData.valueAt(0));
 
             // [3] If the passed-in key is the last key, return null.
             // Because there is only one entry in the map, the first key equals the last key.
-            final TetherIngressKey lastKey = bpfMap.getFirstKey();
+            final TetherDownstream6Key lastKey = bpfMap.getFirstKey();
             assertNull(bpfMap.getNextKey(lastKey));
 
             // The BPF map has two entries now.
@@ -189,7 +192,7 @@
             resultMap.put(mTestData.keyAt(1), mTestData.valueAt(1));
 
             // [4] If the passed-in key is found, return the next key.
-            TetherIngressKey nextKey = bpfMap.getFirstKey();
+            TetherDownstream6Key nextKey = bpfMap.getFirstKey();
             while (nextKey != null) {
                 if (resultMap.remove(nextKey).equals(nextKey)) {
                     fail("Unexpected result: " + nextKey);
@@ -211,23 +214,23 @@
 
     @Test
     public void testUpdateBpfMap() throws Exception {
-        try (BpfMap<TetherIngressKey, TetherIngressValue> bpfMap = getTestMap()) {
+        try (BpfMap<TetherDownstream6Key, TetherDownstream6Value> bpfMap = getTestMap()) {
 
-            final TetherIngressKey key = mTestData.keyAt(0);
-            final TetherIngressValue value = mTestData.valueAt(0);
-            final TetherIngressValue value2 = mTestData.valueAt(1);
+            final TetherDownstream6Key key = mTestData.keyAt(0);
+            final TetherDownstream6Value value = mTestData.valueAt(0);
+            final TetherDownstream6Value value2 = mTestData.valueAt(1);
             assertFalse(bpfMap.deleteEntry(key));
 
             // updateEntry will create an entry if it does not exist already.
             bpfMap.updateEntry(key, value);
             assertTrue(bpfMap.containsKey(key));
-            final TetherIngressValue result = bpfMap.getValue(key);
+            final TetherDownstream6Value result = bpfMap.getValue(key);
             assertEquals(value, result);
 
             // updateEntry will update an entry that already exists.
             bpfMap.updateEntry(key, value2);
             assertTrue(bpfMap.containsKey(key));
-            final TetherIngressValue result2 = bpfMap.getValue(key);
+            final TetherDownstream6Value result2 = bpfMap.getValue(key);
             assertEquals(value2, result2);
 
             assertTrue(bpfMap.deleteEntry(key));
@@ -237,11 +240,11 @@
 
     @Test
     public void testInsertReplaceEntry() throws Exception {
-        try (BpfMap<TetherIngressKey, TetherIngressValue> bpfMap = getTestMap()) {
+        try (BpfMap<TetherDownstream6Key, TetherDownstream6Value> bpfMap = getTestMap()) {
 
-            final TetherIngressKey key = mTestData.keyAt(0);
-            final TetherIngressValue value = mTestData.valueAt(0);
-            final TetherIngressValue value2 = mTestData.valueAt(1);
+            final TetherDownstream6Key key = mTestData.keyAt(0);
+            final TetherDownstream6Value value = mTestData.valueAt(0);
+            final TetherDownstream6Value value2 = mTestData.valueAt(1);
 
             try {
                 bpfMap.replaceEntry(key, value);
@@ -251,7 +254,7 @@
 
             bpfMap.insertEntry(key, value);
             assertTrue(bpfMap.containsKey(key));
-            final TetherIngressValue result = bpfMap.getValue(key);
+            final TetherDownstream6Value result = bpfMap.getValue(key);
             assertEquals(value, result);
             try {
                 bpfMap.insertEntry(key, value);
@@ -260,15 +263,15 @@
 
             bpfMap.replaceEntry(key, value2);
             assertTrue(bpfMap.containsKey(key));
-            final TetherIngressValue result2 = bpfMap.getValue(key);
+            final TetherDownstream6Value result2 = bpfMap.getValue(key);
             assertEquals(value2, result2);
         }
     }
 
     @Test
     public void testIterateBpfMap() throws Exception {
-        try (BpfMap<TetherIngressKey, TetherIngressValue> bpfMap = getTestMap()) {
-            final ArrayMap<TetherIngressKey, TetherIngressValue> resultMap =
+        try (BpfMap<TetherDownstream6Key, TetherDownstream6Value> bpfMap = getTestMap()) {
+            final ArrayMap<TetherDownstream6Key, TetherDownstream6Value> resultMap =
                     new ArrayMap<>(mTestData);
 
             for (int i = 0; i < resultMap.size(); i++) {
@@ -286,7 +289,7 @@
 
     @Test
     public void testIterateEmptyMap() throws Exception {
-        try (BpfMap<TetherIngressKey, TetherIngressValue> bpfMap = getTestMap()) {
+        try (BpfMap<TetherDownstream6Key, TetherDownstream6Value> bpfMap = getTestMap()) {
             // Can't use an int because variables used in a lambda must be final.
             final AtomicInteger count = new AtomicInteger();
             bpfMap.forEach((key, value) -> count.incrementAndGet());
@@ -297,8 +300,8 @@
 
     @Test
     public void testIterateDeletion() throws Exception {
-        try (BpfMap<TetherIngressKey, TetherIngressValue> bpfMap = getTestMap()) {
-            final ArrayMap<TetherIngressKey, TetherIngressValue> resultMap =
+        try (BpfMap<TetherDownstream6Key, TetherDownstream6Value> bpfMap = getTestMap()) {
+            final ArrayMap<TetherDownstream6Key, TetherDownstream6Value> resultMap =
                     new ArrayMap<>(mTestData);
 
             for (int i = 0; i < resultMap.size(); i++) {
@@ -326,13 +329,15 @@
 
     @Test
     public void testInsertOverflow() throws Exception {
-        try (BpfMap<TetherIngressKey, TetherIngressValue> bpfMap = getTestMap()) {
-            final ArrayMap<TetherIngressKey, TetherIngressValue> testData = new ArrayMap<>();
+        try (BpfMap<TetherDownstream6Key, TetherDownstream6Value> bpfMap = getTestMap()) {
+            final ArrayMap<TetherDownstream6Key, TetherDownstream6Value> testData =
+                    new ArrayMap<>();
 
             // Build test data for TEST_MAP_SIZE + 1 entries.
             for (int i = 1; i <= TEST_MAP_SIZE + 1; i++) {
-                testData.put(createTetherIngressKey(i, "2001:db8::1"), createTetherIngressValue(
-                        100, "de:ad:be:ef:00:01", "de:ad:be:ef:00:02", ETH_P_IPV6, 1500));
+                testData.put(createTetherDownstream6Key(i, "2001:db8::1"),
+                        createTetherDownstream6Value(100, "de:ad:be:ef:00:01", "de:ad:be:ef:00:02",
+                        ETH_P_IPV6, 1500));
             }
 
             // Insert #TEST_MAP_SIZE test entries to the map. The map has reached the limit.
diff --git a/Tethering/tests/unit/src/android/net/ip/IpServerTest.java b/Tethering/tests/unit/src/android/net/ip/IpServerTest.java
index 4763558..048b756 100644
--- a/Tethering/tests/unit/src/android/net/ip/IpServerTest.java
+++ b/Tethering/tests/unit/src/android/net/ip/IpServerTest.java
@@ -104,8 +104,8 @@
 import com.android.networkstack.tethering.BpfCoordinator.Ipv6ForwardingRule;
 import com.android.networkstack.tethering.BpfMap;
 import com.android.networkstack.tethering.PrivateAddressCoordinator;
-import com.android.networkstack.tethering.TetherIngressKey;
-import com.android.networkstack.tethering.TetherIngressValue;
+import com.android.networkstack.tethering.TetherDownstream6Key;
+import com.android.networkstack.tethering.TetherDownstream6Value;
 import com.android.networkstack.tethering.TetherLimitKey;
 import com.android.networkstack.tethering.TetherLimitValue;
 import com.android.networkstack.tethering.TetherStatsKey;
@@ -172,7 +172,7 @@
     @Mock private PrivateAddressCoordinator mAddressCoordinator;
     @Mock private NetworkStatsManager mStatsManager;
     @Mock private TetheringConfiguration mTetherConfig;
-    @Mock private BpfMap<TetherIngressKey, TetherIngressValue> mBpfIngressMap;
+    @Mock private BpfMap<TetherDownstream6Key, TetherDownstream6Value> mBpfDownstream6Map;
     @Mock private BpfMap<TetherStatsKey, TetherStatsValue> mBpfStatsMap;
     @Mock private BpfMap<TetherLimitKey, TetherLimitValue> mBpfLimitMap;
 
@@ -296,8 +296,8 @@
                     }
 
                     @Nullable
-                    public BpfMap<TetherIngressKey, TetherIngressValue> getBpfIngressMap() {
-                        return mBpfIngressMap;
+                    public BpfMap<TetherDownstream6Key, TetherDownstream6Value> getBpfIngressMap() {
+                        return mBpfDownstream6Map;
                     }
 
                     @Nullable
@@ -770,15 +770,15 @@
     }
 
     @NonNull
-    private static TetherIngressKey makeIngressKey(int upstreamIfindex,
+    private static TetherDownstream6Key makeIngressKey(int upstreamIfindex,
             @NonNull final InetAddress dst) {
-        return new TetherIngressKey(upstreamIfindex, dst.getAddress());
+        return new TetherDownstream6Key(upstreamIfindex, dst.getAddress());
     }
 
     @NonNull
-    private static TetherIngressValue makeIngressValue(@NonNull final MacAddress dstMac) {
-        return new TetherIngressValue(TEST_IFACE_PARAMS.index, dstMac, TEST_IFACE_PARAMS.macAddr,
-                ETH_P_IPV6, NetworkStackConstants.ETHER_MTU);
+    private static TetherDownstream6Value makeIngressValue(@NonNull final MacAddress dstMac) {
+        return new TetherDownstream6Value(TEST_IFACE_PARAMS.index, dstMac,
+                TEST_IFACE_PARAMS.macAddr, ETH_P_IPV6, NetworkStackConstants.ETHER_MTU);
     }
 
     private <T> T verifyWithOrder(@Nullable InOrder inOrder, @NonNull T t) {
@@ -792,7 +792,7 @@
     private void verifyTetherOffloadRuleAdd(@Nullable InOrder inOrder, int upstreamIfindex,
             @NonNull final InetAddress dst, @NonNull final MacAddress dstMac) throws Exception {
         if (mBpfDeps.isAtLeastS()) {
-            verifyWithOrder(inOrder, mBpfIngressMap).updateEntry(
+            verifyWithOrder(inOrder, mBpfDownstream6Map).updateEntry(
                     makeIngressKey(upstreamIfindex, dst), makeIngressValue(dstMac));
         } else {
             verifyWithOrder(inOrder, mNetd).tetherOffloadRuleAdd(matches(upstreamIfindex, dst,
@@ -803,7 +803,7 @@
     private void verifyNeverTetherOffloadRuleAdd(int upstreamIfindex,
             @NonNull final InetAddress dst, @NonNull final MacAddress dstMac) throws Exception {
         if (mBpfDeps.isAtLeastS()) {
-            verify(mBpfIngressMap, never()).updateEntry(makeIngressKey(upstreamIfindex, dst),
+            verify(mBpfDownstream6Map, never()).updateEntry(makeIngressKey(upstreamIfindex, dst),
                     makeIngressValue(dstMac));
         } else {
             verify(mNetd, never()).tetherOffloadRuleAdd(matches(upstreamIfindex, dst, dstMac));
@@ -812,7 +812,7 @@
 
     private void verifyNeverTetherOffloadRuleAdd() throws Exception {
         if (mBpfDeps.isAtLeastS()) {
-            verify(mBpfIngressMap, never()).updateEntry(any(), any());
+            verify(mBpfDownstream6Map, never()).updateEntry(any(), any());
         } else {
             verify(mNetd, never()).tetherOffloadRuleAdd(any());
         }
@@ -821,7 +821,7 @@
     private void verifyTetherOffloadRuleRemove(@Nullable InOrder inOrder, int upstreamIfindex,
             @NonNull final InetAddress dst, @NonNull final MacAddress dstMac) throws Exception {
         if (mBpfDeps.isAtLeastS()) {
-            verifyWithOrder(inOrder, mBpfIngressMap).deleteEntry(makeIngressKey(upstreamIfindex,
+            verifyWithOrder(inOrder, mBpfDownstream6Map).deleteEntry(makeIngressKey(upstreamIfindex,
                     dst));
         } else {
             // |dstMac| is not required for deleting rules. Used bacause tetherOffloadRuleRemove
@@ -834,7 +834,7 @@
 
     private void verifyNeverTetherOffloadRuleRemove() throws Exception {
         if (mBpfDeps.isAtLeastS()) {
-            verify(mBpfIngressMap, never()).deleteEntry(any());
+            verify(mBpfDownstream6Map, never()).deleteEntry(any());
         } else {
             verify(mNetd, never()).tetherOffloadRuleRemove(any());
         }
@@ -848,7 +848,7 @@
     }
 
     private void resetNetdBpfMapAndCoordinator() throws Exception {
-        reset(mNetd, mBpfIngressMap, mBpfCoordinator);
+        reset(mNetd, mBpfDownstream6Map, mBpfCoordinator);
         when(mNetd.tetherOffloadGetStats()).thenReturn(new TetherStatsParcel[0]);
         when(mNetd.tetherOffloadGetAndClearStats(UPSTREAM_IFINDEX))
                 .thenReturn(buildEmptyTetherStatsParcel(UPSTREAM_IFINDEX));
@@ -874,14 +874,14 @@
         final MacAddress macB = MacAddress.fromString("11:22:33:00:00:0b");
 
         resetNetdBpfMapAndCoordinator();
-        verifyNoMoreInteractions(mBpfCoordinator, mNetd, mBpfIngressMap);
+        verifyNoMoreInteractions(mBpfCoordinator, mNetd, mBpfDownstream6Map);
 
         // TODO: Perhaps verify the interaction of tetherOffloadSetInterfaceQuota and
         // tetherOffloadGetAndClearStats in netd while the rules are changed.
 
         // Events on other interfaces are ignored.
         recvNewNeigh(notMyIfindex, neighA, NUD_REACHABLE, macA);
-        verifyNoMoreInteractions(mBpfCoordinator, mNetd, mBpfIngressMap);
+        verifyNoMoreInteractions(mBpfCoordinator, mNetd, mBpfDownstream6Map);
 
         // Events on this interface are received and sent to netd.
         recvNewNeigh(myIfindex, neighA, NUD_REACHABLE, macA);
@@ -898,9 +898,9 @@
 
         // Link-local and multicast neighbors are ignored.
         recvNewNeigh(myIfindex, neighLL, NUD_REACHABLE, macA);
-        verifyNoMoreInteractions(mBpfCoordinator, mNetd, mBpfIngressMap);
+        verifyNoMoreInteractions(mBpfCoordinator, mNetd, mBpfDownstream6Map);
         recvNewNeigh(myIfindex, neighMC, NUD_REACHABLE, macA);
-        verifyNoMoreInteractions(mBpfCoordinator, mNetd, mBpfIngressMap);
+        verifyNoMoreInteractions(mBpfCoordinator, mNetd, mBpfDownstream6Map);
 
         // A neighbor that is no longer valid causes the rule to be removed.
         // NUD_FAILED events do not have a MAC address.
@@ -922,7 +922,7 @@
         recvNewNeigh(myIfindex, neighB, NUD_REACHABLE, macB);
         resetNetdBpfMapAndCoordinator();
 
-        InOrder inOrder = inOrder(mNetd, mBpfIngressMap);
+        InOrder inOrder = inOrder(mNetd, mBpfDownstream6Map);
         LinkProperties lp = new LinkProperties();
         lp.setInterfaceName(UPSTREAM_IFACE2);
         dispatchTetherConnectionChanged(UPSTREAM_IFACE2, lp, -1);
@@ -950,7 +950,7 @@
         recvNewNeigh(myIfindex, neighA, NUD_REACHABLE, macA);
         // Clear function is called by #updateIpv6ForwardingRules for the IPv6 upstream is lost.
         verify(mBpfCoordinator).tetherOffloadRuleClear(mIpServer);
-        verifyNoMoreInteractions(mBpfCoordinator, mNetd, mBpfIngressMap);
+        verifyNoMoreInteractions(mBpfCoordinator, mNetd, mBpfDownstream6Map);
 
         // Rules can be added again once upstream IPv6 connectivity is available.
         lp.setInterfaceName(UPSTREAM_IFACE);
diff --git a/Tethering/tests/unit/src/com/android/networkstack/tethering/BpfCoordinatorTest.java b/Tethering/tests/unit/src/com/android/networkstack/tethering/BpfCoordinatorTest.java
index 4abaf03..09167a9 100644
--- a/Tethering/tests/unit/src/com/android/networkstack/tethering/BpfCoordinatorTest.java
+++ b/Tethering/tests/unit/src/com/android/networkstack/tethering/BpfCoordinatorTest.java
@@ -154,7 +154,7 @@
     @Mock private INetd mNetd;
     @Mock private IpServer mIpServer;
     @Mock private TetheringConfiguration mTetherConfig;
-    @Mock private BpfMap<TetherIngressKey, TetherIngressValue> mBpfIngressMap;
+    @Mock private BpfMap<TetherDownstream6Key, TetherDownstream6Value> mBpfDownstream6Map;
 
     // Late init since methods must be called by the thread that created this object.
     private TestableNetworkStatsProviderCbBinder mTetherStatsProviderCb;
@@ -194,8 +194,8 @@
                     }
 
                     @Nullable
-                    public BpfMap<TetherIngressKey, TetherIngressValue> getBpfIngressMap() {
-                        return mBpfIngressMap;
+                    public BpfMap<TetherDownstream6Key, TetherDownstream6Value> getBpfIngressMap() {
+                        return mBpfDownstream6Map;
                     }
 
                     @Nullable
@@ -341,8 +341,8 @@
     private void verifyTetherOffloadRuleAdd(@Nullable InOrder inOrder,
             @NonNull Ipv6ForwardingRule rule) throws Exception {
         if (mDeps.isAtLeastS()) {
-            verifyWithOrder(inOrder, mBpfIngressMap).updateEntry(
-                    rule.makeTetherIngressKey(), rule.makeTetherIngressValue());
+            verifyWithOrder(inOrder, mBpfDownstream6Map).updateEntry(
+                    rule.makeTetherDownstream6Key(), rule.makeTetherDownstream6Value());
         } else {
             verifyWithOrder(inOrder, mNetd).tetherOffloadRuleAdd(matches(rule));
         }
@@ -350,7 +350,7 @@
 
     private void verifyNeverTetherOffloadRuleAdd() throws Exception {
         if (mDeps.isAtLeastS()) {
-            verify(mBpfIngressMap, never()).updateEntry(any(), any());
+            verify(mBpfDownstream6Map, never()).updateEntry(any(), any());
         } else {
             verify(mNetd, never()).tetherOffloadRuleAdd(any());
         }
@@ -359,7 +359,8 @@
     private void verifyTetherOffloadRuleRemove(@Nullable InOrder inOrder,
             @NonNull final Ipv6ForwardingRule rule) throws Exception {
         if (mDeps.isAtLeastS()) {
-            verifyWithOrder(inOrder, mBpfIngressMap).deleteEntry(rule.makeTetherIngressKey());
+            verifyWithOrder(inOrder, mBpfDownstream6Map).deleteEntry(
+                    rule.makeTetherDownstream6Key());
         } else {
             verifyWithOrder(inOrder, mNetd).tetherOffloadRuleRemove(matches(rule));
         }
@@ -367,7 +368,7 @@
 
     private void verifyNeverTetherOffloadRuleRemove() throws Exception {
         if (mDeps.isAtLeastS()) {
-            verify(mBpfIngressMap, never()).deleteEntry(any());
+            verify(mBpfDownstream6Map, never()).deleteEntry(any());
         } else {
             verify(mNetd, never()).tetherOffloadRuleRemove(any());
         }
@@ -435,7 +436,7 @@
         // BpfCoordinator#tetherOffloadRuleAdd and BpfCoordinator#tetherOffloadGetAndClearStats.
         // The #verifyTetherOffloadGetAndClearStats can't distinguish who has ever called
         // mBpfStatsMap#getValue and get a wrong calling count which counts all.
-        final InOrder inOrder = inOrder(mNetd, mBpfIngressMap, mBpfLimitMap, mBpfStatsMap);
+        final InOrder inOrder = inOrder(mNetd, mBpfDownstream6Map, mBpfLimitMap, mBpfStatsMap);
         final Ipv6ForwardingRule rule = buildTestForwardingRule(mobileIfIndex, NEIGH_A, MAC_A);
         coordinator.tetherOffloadRuleAdd(mIpServer, rule);
         verifyTetherOffloadRuleAdd(inOrder, rule);
@@ -651,11 +652,11 @@
     }
 
     @Test
-    public void testRuleMakeTetherIngressKey() throws Exception {
+    public void testRuleMakeTetherDownstream6Key() throws Exception {
         final Integer mobileIfIndex = 100;
         final Ipv6ForwardingRule rule = buildTestForwardingRule(mobileIfIndex, NEIGH_A, MAC_A);
 
-        final TetherIngressKey key = rule.makeTetherIngressKey();
+        final TetherDownstream6Key key = rule.makeTetherDownstream6Key();
         assertEquals(key.iif, (long) mobileIfIndex);
         assertTrue(Arrays.equals(key.neigh6, NEIGH_A.getAddress()));
         // iif (4) + neigh6 (16) = 20.
@@ -663,11 +664,11 @@
     }
 
     @Test
-    public void testRuleMakeTetherIngressValue() throws Exception {
+    public void testRuleMakeTetherDownstream6Value() throws Exception {
         final Integer mobileIfIndex = 100;
         final Ipv6ForwardingRule rule = buildTestForwardingRule(mobileIfIndex, NEIGH_A, MAC_A);
 
-        final TetherIngressValue value = rule.makeTetherIngressValue();
+        final TetherDownstream6Value value = rule.makeTetherDownstream6Value();
         assertEquals(value.oif, DOWNSTREAM_IFINDEX);
         assertEquals(value.ethDstMac, MAC_A);
         assertEquals(value.ethSrcMac, DOWNSTREAM_MAC);
@@ -691,7 +692,7 @@
         // Set the unlimited quota as default if the service has never applied a data limit for a
         // given upstream. Note that the data limit only be applied on an upstream which has rules.
         final Ipv6ForwardingRule rule = buildTestForwardingRule(mobileIfIndex, NEIGH_A, MAC_A);
-        final InOrder inOrder = inOrder(mNetd, mBpfIngressMap, mBpfLimitMap, mBpfStatsMap);
+        final InOrder inOrder = inOrder(mNetd, mBpfDownstream6Map, mBpfLimitMap, mBpfStatsMap);
         coordinator.tetherOffloadRuleAdd(mIpServer, rule);
         verifyTetherOffloadRuleAdd(inOrder, rule);
         verifyTetherOffloadSetInterfaceQuota(inOrder, mobileIfIndex, QUOTA_UNLIMITED,
@@ -734,7 +735,7 @@
         // Applying a data limit to the current upstream does not take any immediate action.
         // The data limit could be only set on an upstream which has rules.
         final long limit = 12345;
-        final InOrder inOrder = inOrder(mNetd, mBpfIngressMap, mBpfLimitMap, mBpfStatsMap);
+        final InOrder inOrder = inOrder(mNetd, mBpfDownstream6Map, mBpfLimitMap, mBpfStatsMap);
         mTetherStatsProvider.onSetLimit(mobileIface, limit);
         waitForIdle();
         verifyNeverTetherOffloadSetInterfaceQuota(inOrder);
@@ -779,7 +780,7 @@
         coordinator.addUpstreamNameToLookupTable(ethIfIndex, ethIface);
         coordinator.addUpstreamNameToLookupTable(mobileIfIndex, mobileIface);
 
-        final InOrder inOrder = inOrder(mNetd, mBpfIngressMap, mBpfLimitMap, mBpfStatsMap);
+        final InOrder inOrder = inOrder(mNetd, mBpfDownstream6Map, mBpfLimitMap, mBpfStatsMap);
 
         // Before the rule test, here are the additional actions while the rules are changed.
         // - After adding the first rule on a given upstream, the coordinator adds a data limit.