From 1af2003a4481808e438367282999b97f39c0bf8d Mon Sep 17 00:00:00 2001 From: Vladimir Zhigulin Date: Fri, 2 Feb 2024 08:18:01 +0100 Subject: [PATCH] final renamings --- upf/flowtable.c | 22 +++++----- upf/flowtable.h | 94 ++++++++++++++++++++--------------------- upf/unittest.c | 46 ++++++++++---------- upf/upf.c | 4 +- upf/upf_adf.c | 8 ++-- upf/upf_buffer_opaque.h | 4 +- upf/upf_classify.c | 8 ++-- upf/upf_flow_node.c | 36 ++++++++-------- upf/upf_ipfix.c | 4 +- upf/upf_ipfix.h | 2 +- upf/upf_proxy.c | 2 +- upf/upf_proxy_input.c | 22 +++++----- upf/upf_proxy_output.c | 4 +- upf/upf_tcp_forward.c | 13 +++--- 14 files changed, 133 insertions(+), 136 deletions(-) diff --git a/upf/flowtable.c b/upf/flowtable.c index e0f5c19..a42650d 100644 --- a/upf/flowtable.c +++ b/upf/flowtable.c @@ -75,7 +75,7 @@ flowtable_entry_remove_internal (flowtable_main_t *fm, /* hashtable unlink */ clib_bihash_kv_48_8_t kv = { 0 }; flow_key_t *hash_key = (flow_key_t *) &kv.key; - flow_key_apply_direction (hash_key, &f->key, f->flow_key_direction); + flow_key_apply_direction (hash_key, &f->key, f->key_direction); clib_bihash_add_del_48_8 (&fmt->flows_ht, &kv, 0 /* is_add */); flow_entry_free (fm, fmt, f); @@ -206,9 +206,8 @@ flowtable_lifetime_calculate (flowtable_main_t *fm, flow_key_t const *key) return fm->timer_lifetime[FT_TIMEOUT_TYPE_TCP]; default: - return ip46_address_is_ip4 (&key->ip[FT_FORWARD]) ? - fm->timer_lifetime[FT_TIMEOUT_TYPE_IPV4] : - fm->timer_lifetime[FT_TIMEOUT_TYPE_IPV6]; + return key->is_ip4 ? fm->timer_lifetime[FT_TIMEOUT_TYPE_IPV4] : + fm->timer_lifetime[FT_TIMEOUT_TYPE_IPV6]; } return fm->timer_lifetime[FT_TIMEOUT_TYPE_UNKNOWN]; @@ -241,7 +240,7 @@ flowtable_entry_lookup_create (flowtable_main_t *fm, flowtable_main_per_cpu_t *fmt, clib_bihash_kv_48_8_t *kv, u64 timestamp_ns, u32 const now, - flow_key_direction_t pkt_key_direction, + flow_direction_op_t key_direction, u16 generation, u32 session_index, int *created) { flow_entry_t *f; @@ -262,11 +261,10 @@ flowtable_entry_lookup_create (flowtable_main_t *fm, pool_get_zero (fm->flows, f); - flow_key_apply_direction (&f->key, (flow_key_t *) kv->key, - pkt_key_direction); + flow_key_apply_direction (&f->key, (flow_key_t *) kv->key, key_direction); // make it so FT_INITIATOR corresponds to first packet - f->flow_key_direction = pkt_key_direction; + f->key_direction = key_direction; f->lifetime = flowtable_lifetime_calculate (fm, &f->key); f->active = now; f->flow_start_time = timestamp_ns; @@ -313,10 +311,10 @@ format_flow_key (u8 *s, va_list *args) flow_key_t *key = va_arg (*args, flow_key_t *); return format (s, "proto 0x%x, %U:%u <-> %U:%u, seid 0x%016llx", key->proto, - format_ip46_address, &key->ip[FT_FORWARD], IP46_TYPE_ANY, - clib_net_to_host_u16 (key->port[FT_FORWARD]), - format_ip46_address, &key->ip[FT_REVERSE], IP46_TYPE_ANY, - clib_net_to_host_u16 (key->port[FT_REVERSE]), key->up_seid); + format_ip46_address, &key->ip[FTK_EL_SRC], IP46_TYPE_ANY, + clib_net_to_host_u16 (key->port[FTK_EL_SRC]), + format_ip46_address, &key->ip[FTK_EL_DST], IP46_TYPE_ANY, + clib_net_to_host_u16 (key->port[FTK_EL_DST]), key->up_seid); } u8 * diff --git a/upf/flowtable.h b/upf/flowtable.h index d14ad8a..8f56deb 100644 --- a/upf/flowtable.h +++ b/upf/flowtable.h @@ -56,13 +56,6 @@ typedef enum FT_NEXT_N_NEXT } flowtable_next_t; -// Flowtable direction based on 3 values which can be xored: -// - packet key direction - if key is reversed for packet -// - flow key direction - convert key to index in flow key elements -// - packet flow direction (or just direction) - direction of packet in flow -// Good rule of thumb is to use pkt/flow/key in variable names and on every XOR -// operation "XOR" this names as well. Example: -// pkt_key_direction ^ flow_key_direction = pkt_flow_direction typedef enum { FT_INITIATOR = 0, // direction in which flow was created @@ -72,9 +65,9 @@ typedef enum typedef enum { - FT_FORWARD = 0, // original key direction - FT_REVERSE, // reversed key direction -} __clib_packed flow_key_direction_t; + FTD_OP_SAME = 0, // original key direction + FTD_OP_FLIP, // reversed key direction +} __clib_packed flow_direction_op_t; typedef enum { @@ -82,8 +75,9 @@ typedef enum FTK_EL_DST = 1, // select dst field of pkt in direction } __clib_packed flow_key_el_t; -// Flowtable hashmap key. Fields can be reversed and because of this key access -// usually should use flow_key_direction_t +// Flowtable hashmap key. +// Fields can be reversed and because of this key access usually should use +// flow_direction_op_t determined from packet ip addresses typedef struct { union @@ -94,27 +88,29 @@ typedef struct ip46_address_t ip[FT_DIRECTION_MAX]; u16 port[FT_DIRECTION_MAX]; u8 proto; + u8 is_ip4 : 1; }; u64 key[6]; }; } flow_key_t; -// Key like flow_key_t, but elements are ordered and can be accessed directly -// with flow_direction_t, without accounting for flow_key_direction_t -typedef flow_key_t flow_key_directioned_t; +// Like flow_key_t, but elements are ordered and can be accessed directly with +// flow_direction_t, without accounting for ip address comparison +typedef flow_key_t key_directioned_t; __always_inline void flow_key_apply_direction (flow_key_t *dst_key, const flow_key_t *src_key, - flow_key_direction_t direction) + flow_direction_op_t direction) { dst_key->up_seid = src_key->up_seid; - ip46_address_copy (&dst_key->ip[FT_FORWARD ^ direction], - &src_key->ip[FT_FORWARD]); - ip46_address_copy (&dst_key->ip[FT_REVERSE ^ direction], - &src_key->ip[FT_REVERSE]); - dst_key->port[FT_FORWARD ^ direction] = src_key->port[FT_FORWARD]; - dst_key->port[FT_REVERSE ^ direction] = src_key->port[FT_REVERSE]; + ip46_address_copy (&dst_key->ip[FTK_EL_SRC ^ direction], + &src_key->ip[FTK_EL_SRC]); + ip46_address_copy (&dst_key->ip[FTK_EL_DST ^ direction], + &src_key->ip[FTK_EL_DST]); + dst_key->port[FTK_EL_SRC ^ direction] = src_key->port[FTK_EL_SRC]; + dst_key->port[FTK_EL_DST ^ direction] = src_key->port[FTK_EL_DST]; dst_key->proto = src_key->proto; + dst_key->is_ip4 = src_key->is_ip4; } typedef struct @@ -173,10 +169,10 @@ typedef struct flow_entry /* flow signature */ // key elements can be addressed directily with flow_direction_t - flow_key_directioned_t key; + key_directioned_t key; u32 session_index; - u8 flow_key_direction : 1; // is bihash flow_key_t reversed + u8 key_direction : 1; // flow_direction_op_t of bihash key u8 is_redirect : 1; u8 is_l3_proxy : 1; u8 is_spliced : 1; @@ -311,7 +307,7 @@ u32 flowtable_entry_lookup_create (flowtable_main_t *fm, flowtable_main_per_cpu_t *fmt, clib_bihash_kv_48_8_t *kv, u64 timestamp_ns, u32 const now, - flow_key_direction_t flow_key_direction, + flow_direction_op_t key_direction, u16 generation, u32 session_index, int *created); @@ -362,74 +358,75 @@ flowtable_timeout_start_entry (flowtable_main_t *fm, } static inline void -parse_packet_protocol (udp_header_t *udp, flow_key_direction_t key_direction, +parse_packet_protocol (udp_header_t *udp, flow_direction_op_t key_direction, flow_key_t *key) { if (key->proto == IP_PROTOCOL_UDP || key->proto == IP_PROTOCOL_TCP) { /* tcp and udp ports have the same offset */ - key->port[FT_FORWARD ^ key_direction] = udp->src_port; - key->port[FT_REVERSE ^ key_direction] = udp->dst_port; + key->port[FTK_EL_SRC ^ key_direction] = udp->src_port; + key->port[FTK_EL_DST ^ key_direction] = udp->dst_port; } else { - key->port[FT_FORWARD] = key->port[FT_REVERSE] = 0; + key->port[FTK_EL_SRC] = 0; + key->port[FTK_EL_DST] = 0; } } -static inline flow_key_direction_t +static inline flow_direction_op_t ip4_packet_is_reverse (ip4_header_t *ip4) { return (ip4_address_compare (&ip4->src_address, &ip4->dst_address) < 0) ? - FT_REVERSE : - FT_FORWARD; + FTD_OP_FLIP : + FTD_OP_SAME; } static inline void -parse_ip4_packet (ip4_header_t *ip4, flow_key_direction_t *pkt_key_direction, +parse_ip4_packet (ip4_header_t *ip4, flow_direction_op_t *key_direction, flow_key_t *key) { key->proto = ip4->protocol; - *pkt_key_direction = ip4_packet_is_reverse (ip4); + *key_direction = ip4_packet_is_reverse (ip4); - ip46_address_set_ip4 (&key->ip[FTK_EL_SRC ^ *pkt_key_direction], + ip46_address_set_ip4 (&key->ip[FTK_EL_SRC ^ *key_direction], &ip4->src_address); - ip46_address_set_ip4 (&key->ip[FTK_EL_DST ^ *pkt_key_direction], + ip46_address_set_ip4 (&key->ip[FTK_EL_DST ^ *key_direction], &ip4->dst_address); parse_packet_protocol ((udp_header_t *) ip4_next_header (ip4), - *pkt_key_direction, key); + *key_direction, key); } -static inline flow_key_direction_t +static inline flow_direction_op_t ip6_packet_is_reverse (ip6_header_t *ip6) { return (ip6_address_compare (&ip6->src_address, &ip6->dst_address) < 0) ? - FT_REVERSE : - FT_FORWARD; + FTD_OP_FLIP : + FTD_OP_SAME; } static inline void -parse_ip6_packet (ip6_header_t *ip6, flow_key_direction_t *pkt_key_direction, +parse_ip6_packet (ip6_header_t *ip6, flow_direction_op_t *key_direction, flow_key_t *key) { key->proto = ip6->protocol; - *pkt_key_direction = ip6_packet_is_reverse (ip6); + *key_direction = ip6_packet_is_reverse (ip6); - ip46_address_set_ip6 (&key->ip[FTK_EL_SRC ^ *pkt_key_direction], + ip46_address_set_ip6 (&key->ip[FTK_EL_SRC ^ *key_direction], &ip6->src_address); - ip46_address_set_ip6 (&key->ip[FTK_EL_DST ^ *pkt_key_direction], + ip46_address_set_ip6 (&key->ip[FTK_EL_DST ^ *key_direction], &ip6->dst_address); parse_packet_protocol ((udp_header_t *) ip6_next_header (ip6), - *pkt_key_direction, key); + *key_direction, key); } __clib_unused static inline void flow_mk_key (u64 up_seid, u8 *header, u8 is_ip4, - flow_key_direction_t *pkt_key_direction, + flow_direction_op_t *flow_key_direction, clib_bihash_kv_48_8_t *kv) { flow_key_t *key = (flow_key_t *) &kv->key; @@ -437,16 +434,17 @@ flow_mk_key (u64 up_seid, u8 *header, u8 is_ip4, memset (key, 0, sizeof (*key)); key->up_seid = up_seid; + key->is_ip4 = is_ip4; /* compute 5 tuple key so that 2 half connections * get into the same flow */ if (is_ip4) { - parse_ip4_packet ((ip4_header_t *) header, pkt_key_direction, key); + parse_ip4_packet ((ip4_header_t *) header, flow_key_direction, key); } else { - parse_ip6_packet ((ip6_header_t *) header, pkt_key_direction, key); + parse_ip6_packet ((ip6_header_t *) header, flow_key_direction, key); } } diff --git a/upf/unittest.c b/upf/unittest.c index f52cd5f..b4cc5a8 100644 --- a/upf/unittest.c +++ b/upf/unittest.c @@ -153,36 +153,36 @@ ip_app_test_v4 (void) flow_entry_t flow; memset (&flow, 0, sizeof(flow)); - flow.key.ip[FT_FORWARD].ip4.as_u32 = ip_ue_172_17_0_5.ip4.as_u32; - flow.key.port[FT_FORWARD] = clib_host_to_net_u16(12345); - flow.key.ip[FT_REVERSE].ip4.as_u32 = ip_10_20_20_20.ip4.as_u32; - flow.key.port[FT_REVERSE] = clib_host_to_net_u16(80); + flow.key.ip[FT_INITIATOR].ip4.as_u32 = ip_ue_172_17_0_5.ip4.as_u32; + flow.key.port[FT_INITIATOR] = clib_host_to_net_u16(12345); + flow.key.ip[FT_RESPONDER].ip4.as_u32 = ip_10_20_20_20.ip4.as_u32; + flow.key.port[FT_RESPONDER] = clib_host_to_net_u16(80); UPF_TEST (!upf_app_ip_rule_match (app_id, &flow, &ip_ue_172_17_0_5), "rule mismatch (IPAPP): 172.17.0.5:12345 -> 10.20.20.20:80"); UPF_TEST (upf_app_ip_rule_match (app_id_any, &flow, &ip_ue_172_17_0_5), "rule match (IPANY): 172.17.0.5:12345 -> 10.20.20.20:80"); - flow.key.ip[FT_REVERSE].ip4.as_u32 = ip_10_10_10_10.ip4.as_u32; + flow.key.ip[FT_RESPONDER].ip4.as_u32 = ip_10_10_10_10.ip4.as_u32; UPF_TEST (upf_app_ip_rule_match (app_id, &flow, &ip_ue_172_17_0_5), "rule match (IPAPP): 172.17.0.5:12345 -> 10.10.10.10:80"); UPF_TEST (upf_app_ip_rule_match (app_id_any, &flow, &ip_ue_172_17_0_5), "rule match (IPANY): 172.17.0.5:12345 -> 10.10.10.10:80"); - flow.key.ip[FT_REVERSE].ip4.as_u32 = ip_192_168_0_5.ip4.as_u32; + flow.key.ip[FT_RESPONDER].ip4.as_u32 = ip_192_168_0_5.ip4.as_u32; UPF_TEST (upf_app_ip_rule_match (app_id, &flow, &ip_ue_172_17_0_5), "rule match (IPAPP): 172.17.0.5:12345 -> 192.168.0.5:80"); UPF_TEST (upf_app_ip_rule_match (app_id_any, &flow, &ip_ue_172_17_0_5), "rule match (IPANY): 172.17.0.5:12345 -> 192.168.0.5:80"); - flow.key.port[FT_REVERSE] = clib_host_to_net_u16(9999); + flow.key.port[FT_RESPONDER] = clib_host_to_net_u16(9999); UPF_TEST (!upf_app_ip_rule_match (app_id, &flow, &ip_ue_172_17_0_5), "rule mismatch (IPAPP): 172.17.0.5:12345 -> 192.168.0.5:9999"); UPF_TEST (upf_app_ip_rule_match (app_id_any, &flow, &ip_ue_172_17_0_5), "rule match (IPANY): 172.17.0.5:12345 -> 192.168.0.5:9999"); - flow.key.ip[FT_FORWARD].ip4.as_u32 = ip_10_20_20_20.ip4.as_u32; - flow.key.port[FT_REVERSE] = clib_host_to_net_u16(80); + flow.key.ip[FT_INITIATOR].ip4.as_u32 = ip_10_20_20_20.ip4.as_u32; + flow.key.port[FT_RESPONDER] = clib_host_to_net_u16(80); UPF_TEST (!upf_app_ip_rule_match (app_id, &flow, &ip_ue_172_17_0_5), "rule mismatch (IPAPP): 10.20.20.20:12345 -> 192.168.0.5:80"); UPF_TEST (!upf_app_ip_rule_match (app_id_any, &flow, &ip_ue_172_17_0_5), @@ -228,41 +228,41 @@ ip_app_test_v6 (void) flow_entry_t flow; memset (&flow, 0, sizeof(flow)); - flow.key.ip[FT_FORWARD].ip6.as_u64[0] = ip_ue_2001_db8_11__3.ip6.as_u64[0]; - flow.key.ip[FT_FORWARD].ip6.as_u64[1] = ip_ue_2001_db8_11__3.ip6.as_u64[1]; - flow.key.port[FT_FORWARD] = clib_host_to_net_u16(12345); - flow.key.ip[FT_REVERSE].ip6.as_u64[0] = ip_2001_db8_12__3.ip6.as_u64[0]; - flow.key.ip[FT_REVERSE].ip6.as_u64[1] = ip_2001_db8_12__3.ip6.as_u64[1]; - flow.key.port[FT_REVERSE] = clib_host_to_net_u16(80); + flow.key.ip[FT_INITIATOR].ip6.as_u64[0] = ip_ue_2001_db8_11__3.ip6.as_u64[0]; + flow.key.ip[FT_INITIATOR].ip6.as_u64[1] = ip_ue_2001_db8_11__3.ip6.as_u64[1]; + flow.key.port[FT_INITIATOR] = clib_host_to_net_u16(12345); + flow.key.ip[FT_RESPONDER].ip6.as_u64[0] = ip_2001_db8_12__3.ip6.as_u64[0]; + flow.key.ip[FT_RESPONDER].ip6.as_u64[1] = ip_2001_db8_12__3.ip6.as_u64[1]; + flow.key.port[FT_RESPONDER] = clib_host_to_net_u16(80); UPF_TEST (!upf_app_ip_rule_match (app_id, &flow, &ip_ue_2001_db8_11__3), "rule mismatch (IPAPP): [2001:db8:11::3]:12345 -> [2001:db8:12::3]:80"); UPF_TEST (upf_app_ip_rule_match (app_id_any, &flow, &ip_ue_2001_db8_11__3), "rule match (IPANY): [2001:db8:11::3]:12345 -> [2001:db8:12::3]:80"); - flow.key.ip[FT_REVERSE].ip6.as_u64[0] = ip_2001_db8_12__2.ip6.as_u64[0]; - flow.key.ip[FT_REVERSE].ip6.as_u64[1] = ip_2001_db8_12__2.ip6.as_u64[1]; + flow.key.ip[FT_RESPONDER].ip6.as_u64[0] = ip_2001_db8_12__2.ip6.as_u64[0]; + flow.key.ip[FT_RESPONDER].ip6.as_u64[1] = ip_2001_db8_12__2.ip6.as_u64[1]; UPF_TEST (upf_app_ip_rule_match (app_id, &flow, &ip_ue_2001_db8_11__3), "rule match (IPAPP): [2001:db8:11::3]:12345 -> [2001:db8:12::2]:80"); UPF_TEST (upf_app_ip_rule_match (app_id_any, &flow, &ip_ue_2001_db8_11__3), "rule match (IPANY): [2001:db8:11::3]:12345 -> [2001:db8:12::2]:80"); - flow.key.ip[FT_REVERSE].ip6.as_u64[0] = ip_2001_db8_13__5.ip6.as_u64[0]; - flow.key.ip[FT_REVERSE].ip6.as_u64[1] = ip_2001_db8_13__5.ip6.as_u64[1]; + flow.key.ip[FT_RESPONDER].ip6.as_u64[0] = ip_2001_db8_13__5.ip6.as_u64[0]; + flow.key.ip[FT_RESPONDER].ip6.as_u64[1] = ip_2001_db8_13__5.ip6.as_u64[1]; UPF_TEST (upf_app_ip_rule_match (app_id, &flow, &ip_ue_2001_db8_11__3), "rule match (IPAPP): [2001:db8:11::3]:12345 -> [2001:db8:13::5]:80"); UPF_TEST (upf_app_ip_rule_match (app_id_any, &flow, &ip_ue_2001_db8_11__3), "rule match (IPANY): [2001:db8:11::3]:12345 -> [2001:db8:13::5]:80"); - flow.key.port[FT_REVERSE] = clib_host_to_net_u16(9999); + flow.key.port[FT_RESPONDER] = clib_host_to_net_u16(9999); UPF_TEST (!upf_app_ip_rule_match (app_id, &flow, &ip_ue_2001_db8_11__3), "rule mismatch (IPAPP): [2001:db8:11::3]:12345 -> [2001:db8:13::5]:9999"); UPF_TEST (upf_app_ip_rule_match (app_id_any, &flow, &ip_ue_2001_db8_11__3), "rule match (IPANY): [2001:db8:11::3]:12345 -> [2001:db8:13::5]:9999"); - flow.key.ip[FT_FORWARD].ip6.as_u64[0] = ip_2001_db8_12__3.ip6.as_u64[0]; - flow.key.ip[FT_FORWARD].ip6.as_u64[1] = ip_2001_db8_12__3.ip6.as_u64[1]; - flow.key.port[FT_REVERSE] = clib_host_to_net_u16(80); + flow.key.ip[FT_INITIATOR].ip6.as_u64[0] = ip_2001_db8_12__3.ip6.as_u64[0]; + flow.key.ip[FT_INITIATOR].ip6.as_u64[1] = ip_2001_db8_12__3.ip6.as_u64[1]; + flow.key.port[FT_RESPONDER] = clib_host_to_net_u16(80); UPF_TEST (!upf_app_ip_rule_match (app_id, &flow, &ip_ue_2001_db8_11__3), "rule mismatch (IPAPP): [2001:db8:12::3]:12345 -> [2001:db8:13::5]:80"); UPF_TEST (!upf_app_ip_rule_match (app_id_any, &flow, &ip_ue_2001_db8_11__3), diff --git a/upf/upf.c b/upf/upf.c index 27f6ddb..cc0f6d7 100644 --- a/upf/upf.c +++ b/upf/upf.c @@ -498,11 +498,11 @@ upf_format_buffer_opaque_helper (const vlib_buffer_t *b, u8 *s) s = format ( s, "gtpu.teid: 0x%08x, gtpu.session_index: 0x%x, gtpu.ext_hdr_len: %u, " - "gtpu.data_offset: %u, gtpu.flags: 0x%02x, gtpu.pkt_key_direction: %u, " + "gtpu.data_offset: %u, gtpu.flags: 0x%02x, gtpu.flow_key_direction: %u, " "gtpu.direction: %u, gtpu.pdr_idx: 0x%x, gtpu.flow_id: 0x%x", (u32) (o->gtpu.teid), (u32) (o->gtpu.session_index), (u32) (o->gtpu.ext_hdr_len), (u32) (o->gtpu.data_offset), - (u32) (o->gtpu.flags), (u32) (o->gtpu.pkt_key_direction), + (u32) (o->gtpu.flags), (u32) (o->gtpu.flow_key_direction), (u32) (o->gtpu.direction), (u32) (o->gtpu.pdr_idx), (u32) (o->gtpu.flow_id)); vec_add1 (s, '\n'); diff --git a/upf/upf_adf.c b/upf/upf_adf.c index f98deae..f87e7cd 100644 --- a/upf/upf_adf.c +++ b/upf/upf_adf.c @@ -296,10 +296,10 @@ app_scan_for_uri (u8 *uri, flow_entry_t *flow, struct rules *active, { const ip46_address_t *addr; - flow_key_direction_t pdi_direction = - (pdr->pdi.ue_addr.flags & PFCP_UE_IP_ADDRESS_SD) ? FT_REVERSE : - FT_FORWARD; - addr = &flow->key.ip[direction ^ pdi_direction]; + flow_direction_op_t pdi_dir_op = + (pdr->pdi.ue_addr.flags & PFCP_UE_IP_ADDRESS_SD) ? FTD_OP_FLIP : + FTD_OP_SAME; + addr = &flow->key.ip[direction ^ pdi_dir_op]; upf_debug ("Using %U as UE IP, S/D: %u", format_ip46_address, addr, IP46_TYPE_ANY, !!(pdr->pdi.ue_addr.flags & PFCP_UE_IP_ADDRESS_SD)); diff --git a/upf/upf_buffer_opaque.h b/upf/upf_buffer_opaque.h index 3e0b277..a7a5475 100644 --- a/upf/upf_buffer_opaque.h +++ b/upf/upf_buffer_opaque.h @@ -33,8 +33,8 @@ typedef struct u16 data_offset; /* offset relative to ip hdr */ u8 hdr_flags; u8 flags; - u8 pkt_key_direction : 1; // flow_key_direction_t - u8 direction : 1; // flow_direction_t + u8 flow_key_direction : 1; // flow_direction_op_t + u8 direction : 1; // flow_direction_t u8 is_proxied : 1; u32 pdr_idx; u32 flow_id; diff --git a/upf/upf_classify.c b/upf/upf_classify.c index 1b40cf5..fde2ee2 100644 --- a/upf/upf_classify.c +++ b/upf/upf_classify.c @@ -495,10 +495,10 @@ upf_classify_fn (vlib_main_t *vm, vlib_node_runtime_t *node, */ reclassify_proxy_flow = flow->is_l3_proxy; upf_debug ( - "pkt_direction %s, dir %s\n", - upf_buffer_opaque (b)->gtpu.pkt_key_direction == FT_FORWARD ? - "FT_FORWARD" : - "FT_REVERSE", + "flow_key_direction %s, direction %s\n", + upf_buffer_opaque (b)->gtpu.flow_key_direction == FTD_OP_SAME ? + "FTD_OP_SAME" : + "FTD_OP_FLIP", direction == FT_INITIATOR ? "FT_INITIATOR" : "FT_RESPONDER"); if (flow_side (flow, direction)->next != FT_NEXT_CLASSIFY) diff --git a/upf/upf_flow_node.c b/upf/upf_flow_node.c index f99a76e..fe68677 100644 --- a/upf/upf_flow_node.c +++ b/upf/upf_flow_node.c @@ -72,11 +72,11 @@ format_get_flowinfo (u8 *s, va_list *args) always_inline u32 load_gtpu_flow_info (flowtable_main_t *fm, vlib_buffer_t *b, flow_entry_t *flow, struct rules *r, - flow_key_direction_t pkt_key_direction, u16 generation) + flow_direction_op_t flow_key_direction, u16 generation) { - flow_direction_t direction = flow->flow_key_direction ^ pkt_key_direction; + flow_direction_t direction = flow->key_direction ^ flow_key_direction; - upf_buffer_opaque (b)->gtpu.pkt_key_direction = pkt_key_direction; + upf_buffer_opaque (b)->gtpu.flow_key_direction = flow_key_direction; upf_buffer_opaque (b)->gtpu.direction = direction; upf_buffer_opaque (b)->gtpu.flow_id = flow - fm->flows; @@ -138,7 +138,7 @@ upf_flow_process (vlib_main_t *vm, vlib_node_runtime_t *node, u32 next0, next1; clib_bihash_kv_48_8_t kv0, kv1; int created0, created1; - flow_key_direction_t pkt_key_direction0, pkt_key_direction1; + flow_direction_op_t flow_key_direction0, flow_key_direction1; u32 flow_idx0, flow_idx1; flow_entry_t *flow0, *flow1; u8 *p0, *p1; @@ -169,7 +169,7 @@ upf_flow_process (vlib_main_t *vm, vlib_node_runtime_t *node, UPF_CHECK_INNER_NODE (b1); created0 = created1 = 0; - pkt_key_direction0 = pkt_key_direction1 = 0; + flow_key_direction0 = flow_key_direction1 = 0; if (PREDICT_FALSE ( pool_is_free_index ( @@ -213,12 +213,12 @@ upf_flow_process (vlib_main_t *vm, vlib_node_runtime_t *node, active0 = pfcp_get_rules (sx0, PFCP_ACTIVE); active1 = pfcp_get_rules (sx1, PFCP_ACTIVE); - flow_mk_key (sx0->up_seid, p0, is_ip4, &pkt_key_direction0, &kv0); - flow_mk_key (sx1->up_seid, p1, is_ip4, &pkt_key_direction1, &kv1); + flow_mk_key (sx0->up_seid, p0, is_ip4, &flow_key_direction0, &kv0); + flow_mk_key (sx1->up_seid, p1, is_ip4, &flow_key_direction1, &kv1); /* lookup/create flow */ flow_idx0 = flowtable_entry_lookup_create ( - fm, fmt, &kv0, timestamp_ns, current_time, pkt_key_direction0, + fm, fmt, &kv0, timestamp_ns, current_time, flow_key_direction0, sx0->generation, sx0 - gtm->sessions, &created0); if (created0) { @@ -228,7 +228,7 @@ upf_flow_process (vlib_main_t *vm, vlib_node_runtime_t *node, } flow_idx1 = flowtable_entry_lookup_create ( - fm, fmt, &kv1, timestamp_ns, current_time, pkt_key_direction1, + fm, fmt, &kv1, timestamp_ns, current_time, flow_key_direction1, sx1->generation, sx1 - gtm->sessions, &created1); if (created1) { @@ -265,9 +265,9 @@ upf_flow_process (vlib_main_t *vm, vlib_node_runtime_t *node, /* fill buffer with flow data */ next0 = load_gtpu_flow_info (fm, b0, flow0, active0, - pkt_key_direction0, sx0->generation); + flow_key_direction0, sx0->generation); next1 = load_gtpu_flow_info (fm, b1, flow1, active1, - pkt_key_direction1, sx1->generation); + flow_key_direction1, sx1->generation); /* flowtable counters */ CPT_THRU += 2; @@ -325,7 +325,7 @@ upf_flow_process (vlib_main_t *vm, vlib_node_runtime_t *node, int created = 0; u32 flow_idx; flow_entry_t *flow = NULL; - flow_key_direction_t pkt_key_direction = 0; + flow_direction_op_t flow_key_direction = 0; clib_bihash_kv_48_8_t kv; u8 *p; uword len0; @@ -360,9 +360,9 @@ upf_flow_process (vlib_main_t *vm, vlib_node_runtime_t *node, active0 = pfcp_get_rules (sx0, PFCP_ACTIVE); /* lookup/create flow */ - flow_mk_key (sx0->up_seid, p, is_ip4, &pkt_key_direction, &kv); + flow_mk_key (sx0->up_seid, p, is_ip4, &flow_key_direction, &kv); flow_idx = flowtable_entry_lookup_create ( - fm, fmt, &kv, timestamp_ns, current_time, pkt_key_direction, + fm, fmt, &kv, timestamp_ns, current_time, flow_key_direction, sx0->generation, sx0 - gtm->sessions, &created); if (created) { @@ -383,10 +383,10 @@ upf_flow_process (vlib_main_t *vm, vlib_node_runtime_t *node, flow->session_index = upf_buffer_opaque (b0)->gtpu.session_index; FLOW_DEBUG (fm, flow); - flow_debug ("pkt_key_direction: %u, flow_key_direction: %u, " + flow_debug ("flow_key_direction: %u, key_direction: %u, " "direction: %u c: %u", - pkt_key_direction, flow->flow_key_direction, - pkt_key_direction ^ flow->flow_key_direction, created); + flow_key_direction, flow->key_direction, + flow_key_direction ^ flow->key_direction, created); /* update activity timer */ flow_update (vm, flow, p, is_ip4, @@ -395,7 +395,7 @@ upf_flow_process (vlib_main_t *vm, vlib_node_runtime_t *node, /* fill opaque buffer with flow data */ next0 = load_gtpu_flow_info (fm, b0, flow, active0, - pkt_key_direction, sx0->generation); + flow_key_direction, sx0->generation); flow_debug ("flow next: %u, origin: %u, reverse: %u", next0, flow_side (flow, FT_INITIATOR)->next, flow_side (flow, FT_RESPONDER)->next); diff --git a/upf/upf_ipfix.c b/upf/upf_ipfix.c index df37bbe..279bcfb 100644 --- a/upf/upf_ipfix.c +++ b/upf/upf_ipfix.c @@ -427,7 +427,7 @@ upf_ipfix_export_entry (vlib_main_t *vm, flow_entry_t *f, info = pool_elt_at_index (fm->infos, iidx); context = pool_elt_at_index (fm->contexts, info->context_index); - ASSERT (!!ip46_address_is_ip4 (&f->key.ip[0]) == context->key.is_ip4); + ASSERT (f->key.is_ip4 == context->key.is_ip4); offset = context->next_record_offset_per_worker[my_cpu_number]; template = upf_ipfix_templates + context->key.policy; @@ -923,7 +923,7 @@ upf_ipfix_ensure_flow_ipfix_info (flow_entry_t *f, flow_direction_t direction) ingress_nwi = pool_elt_at_index (gtm->nwis, pdr->pdi.nwi_index); - info_key.is_ip4 = ip46_address_is_ip4 (&f->key.ip[FTK_EL_SRC ^ FT_FORWARD]); + info_key.is_ip4 = f->key.is_ip4; fproto = info_key.is_ip4 ? FIB_PROTOCOL_IP4 : FIB_PROTOCOL_IP6; info_key.ingress_fib_index = ingress_nwi->fib_index[fproto]; info_key.egress_fib_index = egress_nwi->fib_index[fproto]; diff --git a/upf/upf_ipfix.h b/upf/upf_ipfix.h index ea45280..e3857e8 100644 --- a/upf/upf_ipfix.h +++ b/upf/upf_ipfix.h @@ -29,7 +29,7 @@ typedef struct * the NWI used to populate observationDomain{Id,Name} * and observationPointId */ - u32 info_nwi_index; // initator->far->nwi_index + u32 info_nwi_index; // initiator->far->nwi_index u32 sw_if_index; u32 forwarding_policy_index; upf_ipfix_policy_t policy; diff --git a/upf/upf_proxy.c b/upf/upf_proxy.c index 15d7938..b0738cd 100644 --- a/upf/upf_proxy.c +++ b/upf/upf_proxy.c @@ -379,7 +379,7 @@ proxy_start_connect_fn (const u32 *session_index) src = &flow->key.ip[FTK_EL_SRC ^ FT_INITIATOR]; dst = &flow->key.ip[FTK_EL_DST ^ FT_INITIATOR]; - is_ip4 = ip46_address_is_ip4 (dst); + is_ip4 = flow->key.is_ip4; ASSERT (flow_side (flow, FT_INITIATOR)->pdr_id != ~0); pdr = pfcp_get_pdr_by_id (active, flow_side (flow, FT_INITIATOR)->pdr_id); diff --git a/upf/upf_proxy_input.c b/upf/upf_proxy_input.c index 19837d3..cc495f5 100644 --- a/upf/upf_proxy_input.c +++ b/upf/upf_proxy_input.c @@ -126,8 +126,8 @@ static_always_inline u32 splice_tcp_connection (upf_main_t *gtm, flow_entry_t *flow, flow_direction_t direction) { - flow_side_tcp_t *ftc = &flow_side (flow, FT_FORWARD ^ direction)->tcp; - flow_side_tcp_t *rev = &flow_side (flow, FT_REVERSE ^ direction)->tcp; + flow_side_tcp_t *ftc = &flow_side (flow, FTD_OP_SAME ^ direction)->tcp; + flow_side_tcp_t *rev = &flow_side (flow, FTD_OP_FLIP ^ direction)->tcp; transport_connection_t *tc; tcp_connection_t *tcpRx, *tcpTx; session_t *s; @@ -153,8 +153,8 @@ splice_tcp_connection (upf_main_t *gtm, flow_entry_t *flow, tcpTx = tcp_get_connection_from_transport (transport_get_connection ( TRANSPORT_PROTO_TCP, rev->conn_index, rev->thread_index)); - ASSERT (tcp_flow_is_valid (tcpRx, flow, FT_FORWARD ^ direction)); - ASSERT (tcp_flow_is_valid (tcpTx, flow, FT_REVERSE ^ direction)); + ASSERT (tcp_flow_is_valid (tcpRx, flow, FTD_OP_SAME ^ direction)); + ASSERT (tcp_flow_is_valid (tcpTx, flow, FTD_OP_FLIP ^ direction)); if (!tcpRx || !tcpTx) return UPF_PROXY_INPUT_NEXT_TCP_INPUT; @@ -193,12 +193,14 @@ splice_tcp_connection (upf_main_t *gtm, flow_entry_t *flow, } if (ftc->seq_offs == 0) - ftc->seq_offs = direction == FT_FORWARD ? tcpTx->snd_nxt - tcpRx->rcv_nxt : - tcpRx->rcv_nxt - tcpTx->snd_nxt; + ftc->seq_offs = direction == FT_INITIATOR ? + tcpTx->snd_nxt - tcpRx->rcv_nxt : + tcpRx->rcv_nxt - tcpTx->snd_nxt; if (rev->seq_offs == 0) - rev->seq_offs = direction == FT_FORWARD ? tcpTx->rcv_nxt - tcpRx->snd_nxt : - tcpRx->snd_nxt - tcpTx->rcv_nxt; + rev->seq_offs = direction == FT_INITIATOR ? + tcpTx->rcv_nxt - tcpRx->snd_nxt : + tcpRx->snd_nxt - tcpTx->rcv_nxt; /* check fifo, proxy Tx/Rx are connected... */ if (svm_fifo_max_dequeue (s->rx_fifo) != 0 || @@ -376,8 +378,8 @@ upf_proxy_input (vlib_main_t *vm, vlib_node_runtime_t *node, direction = upf_buffer_opaque (b)->gtpu.direction; upf_debug ("direction: %u, buffer: %u, flow: %u", direction, - upf_buffer_opaque (b)->gtpu.pkt_key_direction, - flow->flow_key_direction); + upf_buffer_opaque (b)->gtpu.flow_key_direction, + flow->key_direction); vnet_buffer (b)->ip.rx_sw_if_index = vnet_buffer (b)->sw_if_index[VLIB_RX]; diff --git a/upf/upf_proxy_output.c b/upf/upf_proxy_output.c index da7a24a..cd3a29d 100644 --- a/upf/upf_proxy_output.c +++ b/upf/upf_proxy_output.c @@ -208,8 +208,8 @@ upf_proxy_output (vlib_main_t *vm, vlib_node_runtime_t *node, UPF_ENTER_SUBGRAPH (b, flow->session_index, is_ip4); upf_buffer_opaque (b)->gtpu.flow_id = flow_id; - upf_buffer_opaque (b)->gtpu.pkt_key_direction = - output_direction ^ flow->flow_key_direction; + upf_buffer_opaque (b)->gtpu.flow_key_direction = + output_direction ^ flow->key_direction; upf_buffer_opaque (b)->gtpu.direction = output_direction; upf_buffer_opaque (b)->gtpu.is_proxied = 1; diff --git a/upf/upf_tcp_forward.c b/upf/upf_tcp_forward.c index 88fd427..78b7d00 100644 --- a/upf/upf_tcp_forward.c +++ b/upf/upf_tcp_forward.c @@ -151,13 +151,13 @@ upf_tcp_tstamp_mod (tcp_header_t *th, flow_direction_t direction, /* tsval */ net_sub ( (u32 *) (data + 2), - flow_side (flow, FT_FORWARD ^ direction)->tcp.tsval_offs); + flow_side (flow, FTD_OP_SAME ^ direction)->tcp.tsval_offs); if (tcp_ack (th)) /* tsecr */ net_add ( (u32 *) (data + 6), - flow_side (flow, FT_REVERSE ^ direction)->tcp.tsval_offs); + flow_side (flow, FTD_OP_FLIP ^ direction)->tcp.tsval_offs); } break; @@ -174,7 +174,7 @@ upf_tcp_tstamp_mod (tcp_header_t *th, flow_direction_t direction, for (j = 0; j < blocks; j++) { // TODO: can get rid of this "if" by replacing flow_side with - // direction ^ FT_REVERSE + // direction ^ FTD_OP_FLIP if (direction == FT_INITIATOR) { @@ -203,8 +203,7 @@ upf_tcp_tstamp_mod (tcp_header_t *th, flow_direction_t direction, static uword upf_tcp_forward (vlib_main_t *vm, vlib_node_runtime_t *node, - vlib_frame_t *from_frame, flow_key_direction_t direction, - int is_ip4) + vlib_frame_t *from_frame, int is_ip4) { u32 n_left_from, next_index, *from, *to_next; upf_main_t *gtm = &upf_main; @@ -349,13 +348,13 @@ upf_tcp_forward (vlib_main_t *vm, vlib_node_runtime_t *node, VLIB_NODE_FN (upf_tcp4_forward_node) (vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame) { - return upf_tcp_forward (vm, node, from_frame, FT_REVERSE, /* is_ip4 */ 1); + return upf_tcp_forward (vm, node, from_frame, /* is_ip4 */ 1); } VLIB_NODE_FN (upf_tcp6_forward_node) (vlib_main_t *vm, vlib_node_runtime_t *node, vlib_frame_t *from_frame) { - return upf_tcp_forward (vm, node, from_frame, FT_REVERSE, /* is_ip4 */ 0); + return upf_tcp_forward (vm, node, from_frame, /* is_ip4 */ 0); } /* clang-format off */