diff --git a/include/dp_firewall.h b/include/dp_firewall.h index cf3a39e11..7597930c6 100644 --- a/include/dp_firewall.h +++ b/include/dp_firewall.h @@ -52,16 +52,15 @@ struct dp_fwall_rule { TAILQ_ENTRY(dp_fwall_rule) next_rule; }; -// forward-declaration due to 'struct dp_fwall_rule' being part of 'struct dp_grpc_responder' +// forward-declaration due to 'struct dp_fwall_rule' being part of these structures struct dp_grpc_responder; -// dtto for 'struct vm_entry' which is part of 'struct dp_port' struct dp_port; void dp_init_firewall_rules(struct dp_port *port); int dp_add_firewall_rule(const struct dp_fwall_rule *new_rule, struct dp_port *port); int dp_delete_firewall_rule(const char *rule_id, struct dp_port *port); struct dp_fwall_rule *dp_get_firewall_rule(const char *rule_id, const struct dp_port *port); -enum dp_fwall_action dp_get_firewall_action(struct dp_flow *df, const struct dp_port *src_port, const struct dp_port *dst_port); +enum dp_fwall_action dp_get_firewall_action(struct dp_flow *df, const struct dp_port *in_port, const struct dp_port *out_port); int dp_list_firewall_rules(const struct dp_port *port, struct dp_grpc_responder *responder); void dp_del_all_firewall_rules(struct dp_port *port); diff --git a/include/dp_flow.h b/include/dp_flow.h index 02c9cd527..a011615ec 100644 --- a/include/dp_flow.h +++ b/include/dp_flow.h @@ -154,7 +154,7 @@ void dp_free_flow(struct dp_ref *ref); void dp_free_network_nat_port(const struct flow_value *cntrack); void dp_remove_nat_flows(uint16_t port_id, int nat_type); // TODO create proper enum! void dp_remove_neighnat_flows(uint32_t ipv4, uint32_t vni, uint16_t min_port, uint16_t max_port); -void dp_remove_vm_flows(uint16_t port_id, uint32_t ipv4, uint32_t vni); +void dp_remove_iface_flows(uint16_t port_id, uint32_t ipv4, uint32_t vni); hash_sig_t dp_get_conntrack_flow_hash_value(const struct flow_key *key); diff --git a/include/dp_iface.h b/include/dp_iface.h new file mode 100644 index 000000000..514317628 --- /dev/null +++ b/include/dp_iface.h @@ -0,0 +1,42 @@ +#ifndef __INCLUDE_DP_IFACE_H__ +#define __INCLUDE_DP_IFACE_H__ + +#include "dp_port.h" + +#ifdef __cplusplus +extern "C" { +#endif + +int dp_ifaces_init(int socket_id); +void dp_ifaces_free(void); + +int dp_map_iface_id(const char iface_id[DP_IFACE_ID_MAX_LEN], struct dp_port *port); +void dp_unmap_iface_id(const char iface_id[DP_IFACE_ID_MAX_LEN]); +struct dp_port *dp_get_port_with_iface_id(const char iface_id[DP_IFACE_ID_MAX_LEN]); + +int dp_setup_iface(struct dp_port *port, int vni); +void dp_delete_iface(struct dp_port *port); + + +static __rte_always_inline +bool dp_arp_cycle_needed(const struct dp_port *port) +{ + static struct rte_ether_addr nul_mac = {0}; + + return port->iface.ready + && rte_is_same_ether_addr(&port->neigh_mac, &nul_mac); +} + +static __rte_always_inline +void dp_fill_ether_hdr(struct rte_ether_hdr *ether_hdr, const struct dp_port *port, uint16_t ether_type) +{ + rte_ether_addr_copy(&port->neigh_mac, ðer_hdr->dst_addr); + rte_ether_addr_copy(&port->own_mac, ðer_hdr->src_addr); + ether_hdr->ether_type = htons(ether_type); +} + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/dp_lb.h b/include/dp_lb.h index 5e3452fc5..cd27ec31c 100644 --- a/include/dp_lb.h +++ b/include/dp_lb.h @@ -36,9 +36,9 @@ struct lb_value { int dp_lb_init(int socket_id); void dp_lb_free(void); -bool dp_is_ip_lb(uint32_t vm_ip, uint32_t vni); -uint32_t dp_get_lb_ip(uint32_t vm_ip, uint32_t vni); -uint8_t *dp_lb_get_backend_ip(uint32_t v_ip, uint32_t vni, rte_be16_t port, uint8_t proto); +bool dp_is_ip_lb(uint32_t ol_ip, uint32_t vni); +uint32_t dp_get_lb_ip(uint32_t ol_ip, uint32_t vni); +uint8_t *dp_lb_get_backend_ip(uint32_t ol_ip, uint32_t vni, rte_be16_t port, uint8_t proto); bool dp_is_lb_enabled(void); int dp_del_lb_back_ip(const void *id_key, const uint8_t *back_ip); int dp_add_lb_back_ip(const void *id_key, const uint8_t *back_ip, uint8_t ip_size); diff --git a/include/dp_lpm.h b/include/dp_lpm.h index b3b1c9724..5998fbb8c 100644 --- a/include/dp_lpm.h +++ b/include/dp_lpm.h @@ -37,21 +37,21 @@ extern "C" { #define DP_LIST_EXT_ROUTES true #define DP_LIST_INT_ROUTES false -struct vm_route { +struct dp_iface_route { int vni; uint8_t nh_ipv6[16]; }; -const struct dp_port *dp_get_ip4_dst_port(const struct dp_port *port, +const struct dp_port *dp_get_ip4_out_port(const struct dp_port *in_port, int t_vni, const struct dp_flow *df, - struct vm_route *route, + struct dp_iface_route *route, uint32_t *route_key); -const struct dp_port *dp_get_ip6_dst_port(const struct dp_port *port, +const struct dp_port *dp_get_ip6_out_port(const struct dp_port *in_port, int t_vni, const struct rte_ipv6_hdr *ipv6_hdr, - struct vm_route *route); + struct dp_iface_route *route); uint32_t dp_get_gw_ip4(void); const uint8_t *dp_get_gw_ip6(void); diff --git a/include/dp_nat.h b/include/dp_nat.h index 7298c456a..a337d7b1d 100644 --- a/include/dp_nat.h +++ b/include/dp_nat.h @@ -44,9 +44,9 @@ typedef struct network_nat_entry { struct snat_data { uint32_t vip_ip; - uint32_t network_nat_ip; - uint16_t network_nat_port_range[2]; - uint8_t ul_ip6[16]; /* VIP underlady */ + uint32_t nat_ip; + uint16_t nat_port_range[2]; + uint8_t ul_vip_ip6[16]; /* VIP underlay */ uint8_t ul_nat_ip6[16]; /* NAT Gateway underlay */ uint64_t log_timestamp; }; @@ -56,9 +56,9 @@ struct dnat_data { }; struct netnat_portmap_key { - uint32_t vm_src_ip; + uint32_t iface_src_ip; uint32_t vni; - uint16_t vm_src_port; + uint16_t iface_src_port; } __rte_packed; struct netnat_portmap_data { @@ -83,9 +83,15 @@ struct nat_check_result { int dp_nat_init(int socket_id); void dp_nat_free(void); -int dp_del_vm_snat_ip(uint32_t vm_ip, uint32_t vni); -uint32_t dp_get_vm_snat_ip(uint32_t vm_ip, uint32_t vni); -int dp_set_vm_snat_ip(uint32_t vm_ip, uint32_t s_ip, uint32_t vni, const uint8_t ul_ipv6[DP_VNF_IPV6_ADDR_SIZE]); +uint32_t dp_get_iface_vip_ip(uint32_t iface_ip, uint32_t vni); +int dp_set_iface_vip_ip(uint32_t iface_ip, uint32_t vip_ip, uint32_t vni, + const uint8_t ul_ipv6[DP_VNF_IPV6_ADDR_SIZE]); +int dp_del_iface_vip_ip(uint32_t iface_ip, uint32_t vni); + +uint32_t dp_get_iface_nat_ip(uint32_t iface_ip, uint32_t vni); +int dp_set_iface_nat_ip(uint32_t iface_ip, uint32_t nat_ip, uint32_t vni, uint16_t min_port, uint16_t max_port, + const uint8_t ul_ipv6[DP_VNF_IPV6_ADDR_SIZE]); +int dp_del_iface_nat_ip(uint32_t iface_ip, uint32_t vni); int dp_del_dnat_ip(uint32_t d_ip, uint32_t vni); struct dnat_data *dp_get_dnat_data(uint32_t d_ip, uint32_t vni); @@ -106,16 +112,13 @@ int dp_del_network_nat_entry(uint32_t nat_ipv4, const uint8_t nat_ipv6[DP_VNF_IP const uint8_t *dp_get_network_nat_underlay_ip(uint32_t nat_ipv4, const uint8_t nat_ipv6[DP_VNF_IPV6_ADDR_SIZE], uint32_t vni, uint16_t min_port, uint16_t max_port); -uint32_t dp_get_vm_network_snat_ip(uint32_t vm_ip, uint32_t vni); -int dp_set_vm_network_snat_ip(uint32_t vm_ip, uint32_t s_ip, uint32_t vni, uint16_t min_port, uint16_t max_port, - const uint8_t ul_ipv6[DP_VNF_IPV6_ADDR_SIZE]); -int dp_del_vm_network_snat_ip(uint32_t vm_ip, uint32_t vni); int dp_allocate_network_snat_port(struct snat_data *snat_data, struct dp_flow *df, uint32_t vni); const uint8_t *dp_lookup_network_nat_underlay_ip(struct dp_flow *df); int dp_remove_network_snat_port(const struct flow_value *cntrack); + int dp_list_nat_local_entries(uint32_t nat_ip, struct dp_grpc_responder *responder); int dp_list_nat_neigh_entries(uint32_t nat_ip, struct dp_grpc_responder *responder); -struct snat_data *dp_get_vm_snat_data(uint32_t vm_ip, uint32_t vni); +struct snat_data *dp_get_iface_snat_data(uint32_t iface_ip, uint32_t vni); void dp_del_all_neigh_nat_entries_in_vni(uint32_t vni); diff --git a/include/dp_port.h b/include/dp_port.h index bd298d500..8a5ecbc95 100644 --- a/include/dp_port.h +++ b/include/dp_port.h @@ -14,25 +14,24 @@ extern "C" { #endif -#define VM_IFACE_ID_MAX_LEN 64 +#define DP_IFACE_ID_MAX_LEN 64 -struct macip_entry { - struct rte_ether_addr own_mac; - struct rte_ether_addr neigh_mac; +struct dp_iface_cfg { uint32_t own_ip; uint32_t neigh_ip; - uint8_t depth; + uint8_t ip_depth; uint8_t dhcp_ipv6[16]; - uint8_t vm_ipv6[16]; + uint8_t own_ipv6[16]; + uint8_t ip6_depth; uint32_t pxe_ip; - char pxe_str[VM_MACHINE_PXE_MAX_LEN]; + char pxe_str[DP_IFACE_PXE_MAX_LEN]; }; -struct vm_entry { +struct dp_port_iface { struct dp_fwall_head fwall_head; - struct macip_entry info; + struct dp_iface_cfg cfg; uint32_t vni; - char machineid[VM_IFACE_ID_MAX_LEN]; + char id[DP_IFACE_ID_MAX_LEN]; uint8_t ul_ipv6[16]; bool ready; }; @@ -48,7 +47,9 @@ struct dp_port { char dev_name[RTE_ETH_NAME_MAX_LEN]; uint8_t peer_pf_hairpin_tx_rx_queue_offset; uint16_t peer_pf_port_id; - struct vm_entry vm; + struct rte_ether_addr own_mac; + struct rte_ether_addr neigh_mac; + struct dp_port_iface iface; struct rte_flow *default_jump_flow; struct rte_flow *default_capture_flow; bool captured; @@ -78,24 +79,24 @@ int dp_stop_port(struct dp_port *port); static __rte_always_inline int dp_load_mac(struct dp_port *port) { - return rte_eth_macaddr_get(port->port_id, &port->vm.info.own_mac); + return rte_eth_macaddr_get(port->port_id, &port->own_mac); } static __rte_always_inline -const uint8_t *dp_get_port_ul_ip6(const struct dp_port *port) +const uint8_t *dp_get_port_ul_ipv6(const struct dp_port *port) { - return port->vm.ready ? port->vm.ul_ipv6 : dp_conf_get_underlay_ip(); + return port->iface.ready ? port->iface.ul_ipv6 : dp_conf_get_underlay_ip(); } static __rte_always_inline -struct dp_port *dp_get_port(struct rte_mbuf *m) +struct dp_port *dp_get_in_port(struct rte_mbuf *m) { // m->port should've already been validated return _dp_port_table[m->port]; } static __rte_always_inline -struct dp_port *dp_get_dst_port(struct dp_flow *df) +struct dp_port *dp_get_out_port(struct dp_flow *df) { // df->nxt_hop should've already been validated return _dp_port_table[df->nxt_hop]; diff --git a/include/dp_util.h b/include/dp_util.h index 43e52fd43..7055ff6dd 100644 --- a/include/dp_util.h +++ b/include/dp_util.h @@ -15,7 +15,7 @@ extern "C" { #include #define DP_FIREWALL_ID_MAX_LEN 64 -#define VM_MACHINE_PXE_MAX_LEN 32 +#define DP_IFACE_PXE_MAX_LEN 32 #define DP_LB_ID_MAX_LEN 64 #define DP_LB_MAX_PORTS 16 diff --git a/include/dp_virtsvc.h b/include/dp_virtsvc.h index f57f4e40c..6714387e3 100644 --- a/include/dp_virtsvc.h +++ b/include/dp_virtsvc.h @@ -106,7 +106,7 @@ int dp_virtsvc_get_pf_route(struct dp_virtsvc *virtsvc, uint16_t *pf_port_id, int *conn_idx); -void dp_virtsvc_del_vm(uint16_t port_id); +void dp_virtsvc_del_iface(uint16_t port_id); int dp_virtsvc_get_used_ports_telemetry(struct rte_tel_data *dict); diff --git a/include/dp_vm.h b/include/dp_vm.h deleted file mode 100644 index 09a818b3f..000000000 --- a/include/dp_vm.h +++ /dev/null @@ -1,42 +0,0 @@ -#ifndef __DP_VM_H__ -#define __DP_VM_H__ - -#include "dp_port.h" - -#ifdef __cplusplus -extern "C" { -#endif - -int dp_vms_init(int socket_id); -void dp_vms_free(void); - -int dp_map_vm_handle(const char key[VM_IFACE_ID_MAX_LEN], struct dp_port *port); -void dp_unmap_vm_handle(const void *key); -struct dp_port *dp_get_port_with_vm_handle(const void *key); - -int dp_setup_vm(struct dp_port *port, int vni); -void dp_del_vm(struct dp_port *port); - - -static __rte_always_inline -bool dp_arp_cycle_needed(const struct dp_port *port) -{ - static struct rte_ether_addr nul_mac = {0}; - - return port->vm.ready - && rte_is_same_ether_addr(&port->vm.info.neigh_mac, &nul_mac); -} - -static __rte_always_inline -void dp_fill_ether_hdr(struct rte_ether_hdr *ether_hdr, const struct dp_port *port, uint16_t ether_type) -{ - rte_ether_addr_copy(&port->vm.info.neigh_mac, ðer_hdr->dst_addr); - rte_ether_addr_copy(&port->vm.info.own_mac, ðer_hdr->src_addr); - ether_hdr->ether_type = htons(ether_type); -} - -#ifdef __cplusplus -} -#endif - -#endif diff --git a/include/grpc/dp_grpc_api.h b/include/grpc/dp_grpc_api.h index dcb38d905..e9b6370a9 100644 --- a/include/grpc/dp_grpc_api.h +++ b/include/grpc/dp_grpc_api.h @@ -4,7 +4,7 @@ #include #include "dp_firewall.h" #include "dp_util.h" -#include "dp_vm.h" +#include "dp_iface.h" #include "monitoring/dp_monitoring.h" #ifdef __cplusplus @@ -74,18 +74,18 @@ enum dpgrpc_capture_iface_type { }; struct dpgrpc_iface { - char iface_id[VM_IFACE_ID_MAX_LEN]; + char iface_id[DP_IFACE_ID_MAX_LEN]; uint32_t ip4_addr; uint8_t ip6_addr[DP_VNF_IPV6_ADDR_SIZE]; uint32_t vni; uint32_t ip4_pxe_addr; // request (create) only - char pxe_str[VM_MACHINE_PXE_MAX_LEN]; // request (create) only + char pxe_str[DP_IFACE_PXE_MAX_LEN]; // request (create) only char pci_name[RTE_ETH_NAME_MAX_LEN]; uint8_t ul_addr6[DP_VNF_IPV6_ADDR_SIZE]; // reply only }; struct dpgrpc_iface_id { - char iface_id[VM_IFACE_ID_MAX_LEN]; + char iface_id[DP_IFACE_ID_MAX_LEN]; }; struct dpgrpc_address { @@ -100,7 +100,7 @@ struct dpgrpc_address { struct dpgrpc_prefix { struct dpgrpc_address addr; uint32_t length; - char iface_id[VM_IFACE_ID_MAX_LEN]; + char iface_id[DP_IFACE_ID_MAX_LEN]; }; struct dpgrpc_route { @@ -113,12 +113,12 @@ struct dpgrpc_route { struct dpgrpc_vip { struct dpgrpc_address addr; - char iface_id[VM_IFACE_ID_MAX_LEN]; + char iface_id[DP_IFACE_ID_MAX_LEN]; uint8_t ul_addr6[DP_VNF_IPV6_ADDR_SIZE]; // reply only }; struct dpgrpc_nat { - char iface_id[VM_IFACE_ID_MAX_LEN]; // local only + char iface_id[DP_IFACE_ID_MAX_LEN]; // local only struct dpgrpc_address addr; uint16_t min_port; uint16_t max_port; @@ -150,12 +150,12 @@ struct dpgrpc_lb_target { }; struct dpgrpc_fwrule { - char iface_id[VM_IFACE_ID_MAX_LEN]; + char iface_id[DP_IFACE_ID_MAX_LEN]; struct dp_fwall_rule rule; }; struct dpgrpc_fwrule_id { - char iface_id[VM_IFACE_ID_MAX_LEN]; + char iface_id[DP_IFACE_ID_MAX_LEN]; char rule_id[DP_FIREWALL_ID_MAX_LEN]; }; @@ -173,7 +173,7 @@ struct dpgrpc_versions { struct dpgrpc_capture_interface { enum dpgrpc_capture_iface_type type; union { - char iface_id[VM_IFACE_ID_MAX_LEN]; + char iface_id[DP_IFACE_ID_MAX_LEN]; uint8_t pf_index; } spec; }; diff --git a/src/dp_cntrack.c b/src/dp_cntrack.c index e25580c8d..63ef4b1a8 100644 --- a/src/dp_cntrack.c +++ b/src/dp_cntrack.c @@ -94,7 +94,7 @@ static __rte_always_inline void dp_cntrack_init_flow_offload_flags(struct flow_v static __rte_always_inline void dp_cntrack_change_flow_offload_flags(struct rte_mbuf *m, struct flow_value *flow_val, struct dp_flow *df) { bool offload_other_pf = false; - struct dp_port *port = dp_get_port(m); + struct dp_port *port = dp_get_in_port(m); if (!offload_mode_enabled) return; @@ -267,7 +267,7 @@ static __rte_always_inline int dp_get_flow_val(struct rte_mbuf *m, struct dp_flo return ret; } // create new flow if needed - *p_flow_val = flow_table_insert_entry(curr_key, df, dp_get_port(m)); + *p_flow_val = flow_table_insert_entry(curr_key, df, dp_get_in_port(m)); if (unlikely(!*p_flow_val)) { DPS_LOG_WARNING("Failed to create a new flow table entry"); return DP_ERROR; diff --git a/src/dp_firewall.c b/src/dp_firewall.c index c7f015105..618dcd34f 100644 --- a/src/dp_firewall.c +++ b/src/dp_firewall.c @@ -8,7 +8,7 @@ void dp_init_firewall_rules(struct dp_port *port) { - TAILQ_INIT(&port->vm.fwall_head); + TAILQ_INIT(&port->iface.fwall_head); } int dp_add_firewall_rule(const struct dp_fwall_rule *new_rule, struct dp_port *port) @@ -19,7 +19,7 @@ int dp_add_firewall_rule(const struct dp_fwall_rule *new_rule, struct dp_port *p return DP_ERROR; *rule = *new_rule; - TAILQ_INSERT_TAIL(&port->vm.fwall_head, rule, next_rule); + TAILQ_INSERT_TAIL(&port->iface.fwall_head, rule, next_rule); return DP_OK; } @@ -27,7 +27,7 @@ int dp_add_firewall_rule(const struct dp_fwall_rule *new_rule, struct dp_port *p int dp_delete_firewall_rule(const char *rule_id, struct dp_port *port) { - struct dp_fwall_head *fwall_head = &port->vm.fwall_head; + struct dp_fwall_head *fwall_head = &port->iface.fwall_head; struct dp_fwall_rule *rule, *next_rule; for (rule = TAILQ_FIRST(fwall_head); rule != NULL; rule = next_rule) { @@ -46,7 +46,7 @@ struct dp_fwall_rule *dp_get_firewall_rule(const char *rule_id, const struct dp_ { struct dp_fwall_rule *rule; - TAILQ_FOREACH(rule, &port->vm.fwall_head, next_rule) + TAILQ_FOREACH(rule, &port->iface.fwall_head, next_rule) if (memcmp(rule->rule_id, rule_id, sizeof(rule->rule_id)) == 0) return rule; @@ -60,7 +60,7 @@ int dp_list_firewall_rules(const struct dp_port *port, struct dp_grpc_responder dp_grpc_set_multireply(responder, sizeof(*reply)); - TAILQ_FOREACH(rule, &port->vm.fwall_head, next_rule) { + TAILQ_FOREACH(rule, &port->iface.fwall_head, next_rule) { reply = dp_grpc_add_reply(responder); if (!reply) return DP_GRPC_ERR_OUT_OF_MEMORY; @@ -159,27 +159,27 @@ static __rte_always_inline enum dp_fwall_action dp_get_egress_action(const struc } enum dp_fwall_action dp_get_firewall_action(struct dp_flow *df, - const struct dp_port *src_port, - const struct dp_port *dst_port) + const struct dp_port *in_port, + const struct dp_port *out_port) { enum dp_fwall_action egress_action; struct dp_fwall_rule *rule; /* Outgoing traffic to PF (VF Egress, PF Ingress), PF has no Ingress rules */ - if (dst_port->is_pf) - return dp_get_egress_action(df, &src_port->vm.fwall_head); + if (out_port->is_pf) + return dp_get_egress_action(df, &in_port->iface.fwall_head); /* Incoming from PF, PF has no Egress rules */ - if (src_port->is_pf) + if (in_port->is_pf) egress_action = DP_FWALL_ACCEPT; /* Incoming from VF. Check originating VF's Egress rules */ else - egress_action = dp_get_egress_action(df, &src_port->vm.fwall_head); + egress_action = dp_get_egress_action(df, &in_port->iface.fwall_head); if (egress_action != DP_FWALL_ACCEPT) return DP_FWALL_DROP; - rule = dp_is_matched_in_fwall_list(df, &dst_port->vm.fwall_head, DP_FWALL_INGRESS, NULL); + rule = dp_is_matched_in_fwall_list(df, &out_port->iface.fwall_head, DP_FWALL_INGRESS, NULL); if (!rule || rule->action != DP_FWALL_ACCEPT) return DP_FWALL_DROP; @@ -188,7 +188,7 @@ enum dp_fwall_action dp_get_firewall_action(struct dp_flow *df, void dp_del_all_firewall_rules(struct dp_port *port) { - struct dp_fwall_head *fwall_head = &port->vm.fwall_head; + struct dp_fwall_head *fwall_head = &port->iface.fwall_head; struct dp_fwall_rule *rule; while ((rule = TAILQ_FIRST(fwall_head)) != NULL) { diff --git a/src/dp_flow.c b/src/dp_flow.c index bb0a292f3..121f2071d 100644 --- a/src/dp_flow.c +++ b/src/dp_flow.c @@ -108,8 +108,8 @@ static __rte_always_inline void dp_mark_vnf_type(struct dp_flow *df, const struc } else { vnf_val.alias_pfx.ip = key->ip_src; vnf_val.alias_pfx.length = 32; - s_data = dp_get_vm_snat_data(key->ip_src, key->vni); - if (s_data && s_data->network_nat_ip != 0) + s_data = dp_get_iface_snat_data(key->ip_src, key->vni); + if (s_data && s_data->nat_ip != 0) key->vnf = (uint8_t)DP_VNF_TYPE_NAT; else if (!DP_FAILED(dp_get_vnf_entry(&vnf_val, DP_VNF_TYPE_LB_ALIAS_PFX, port, !DP_VNF_MATCH_ALL_PORT_ID))) key->vnf = (uint8_t)DP_VNF_TYPE_LB_ALIAS_PFX; @@ -121,7 +121,7 @@ static __rte_always_inline void dp_mark_vnf_type(struct dp_flow *df, const struc int dp_build_flow_key(struct flow_key *key /* out */, struct rte_mbuf *m /* in */) { struct dp_flow *df = dp_get_flow_ptr(m); - const struct dp_port *port = dp_get_port(m); + const struct dp_port *port = dp_get_in_port(m); int ret = DP_OK; key->ip_dst = ntohl(df->dst.dst_addr); @@ -132,7 +132,7 @@ int dp_build_flow_key(struct flow_key *key /* out */, struct rte_mbuf *m /* in * if (port->is_pf) key->vni = df->tun_info.dst_vni; else - key->vni = port->vm.vni; + key->vni = port->iface.vni; dp_mark_vnf_type(df, port, key); @@ -458,7 +458,7 @@ void dp_remove_neighnat_flows(uint32_t ipv4, uint32_t vni, uint16_t min_port, ui } } -void dp_remove_vm_flows(uint16_t port_id, uint32_t ipv4, uint32_t vni) +void dp_remove_iface_flows(uint16_t port_id, uint32_t ipv4, uint32_t vni) { struct flow_value *flow_val = NULL; const struct flow_key *next_key; diff --git a/src/dp_iface.c b/src/dp_iface.c new file mode 100644 index 000000000..ceaba37b1 --- /dev/null +++ b/src/dp_iface.c @@ -0,0 +1,94 @@ +#include "dp_iface.h" +#include "dp_vni.h" + +static struct rte_hash *iface_id_table = NULL; + +int dp_ifaces_init(int socket_id) +{ + iface_id_table = dp_create_jhash_table(DP_MAX_PORTS, DP_IFACE_ID_MAX_LEN, + "iface_id_table", socket_id); + if (!iface_id_table) + return DP_ERROR; + + return DP_OK; +} + +void dp_ifaces_free(void) +{ + dp_free_jhash_table(iface_id_table); +} + +int dp_map_iface_id(const char iface_id[DP_IFACE_ID_MAX_LEN], struct dp_port *port) +{ + hash_sig_t hash = rte_hash_hash(iface_id_table, iface_id); + int ret; + + ret = rte_hash_lookup_with_hash(iface_id_table, iface_id, hash); + if (ret != -ENOENT) { + if (DP_FAILED(ret)) + DPS_LOG_ERR("VM handle lookup failed", DP_LOG_RET(ret)); + else + DPS_LOG_ERR("VM handle already exists"); + return DP_ERROR; + } + + ret = rte_hash_add_key_with_hash_data(iface_id_table, iface_id, hash, port); + if (DP_FAILED(ret)) { + DPS_LOG_ERR("Cannot add VM handle data", DP_LOG_PORT(port), DP_LOG_RET(ret)); + return DP_ERROR; + } + + static_assert(sizeof(port->iface.id) == DP_IFACE_ID_MAX_LEN, "Incompatible interface ID size"); + rte_memcpy(port->iface.id, iface_id, DP_IFACE_ID_MAX_LEN); + + return DP_OK; +} + +void dp_unmap_iface_id(const char iface_id[DP_IFACE_ID_MAX_LEN]) +{ + rte_hash_del_key(iface_id_table, iface_id); +} + +struct dp_port *dp_get_port_with_iface_id(const char iface_id[DP_IFACE_ID_MAX_LEN]) +{ + struct dp_port *port; + int ret; + + ret = rte_hash_lookup_data(iface_id_table, iface_id, (void **)&port); + if (DP_FAILED(ret)) { + if (ret != -ENOENT) + DPS_LOG_ERR("Failed to look the VM port-id up", DP_LOG_RET(ret)); + return NULL; + } + + return port; +} + + +int dp_setup_iface(struct dp_port *port, int vni) +{ + if (DP_FAILED(dp_create_vni_route_tables(vni, port->socket_id))) + return DP_ERROR; + + dp_init_firewall_rules(port); + port->iface.vni = vni; + port->iface.ready = 1; + return DP_OK; +} + +void dp_delete_iface(struct dp_port *port) +{ + uint32_t vni = port->iface.vni; + + dp_del_route(port, vni, port->iface.cfg.own_ip, 32); + dp_del_route6(port, vni, port->iface.cfg.dhcp_ipv6, 128); + + if (DP_FAILED(dp_delete_vni_route_tables(vni))) + DPS_LOG_WARNING("Unable to delete route tables", DP_LOG_VNI(vni)); + + dp_del_all_firewall_rules(port); + + memset(&port->iface, 0, sizeof(port->iface)); + // own mac address needs to be refilled due to the above cleaning process + dp_load_mac(port); +} diff --git a/src/dp_internal_stats.c b/src/dp_internal_stats.c index 6b812f6a1..d957a2855 100644 --- a/src/dp_internal_stats.c +++ b/src/dp_internal_stats.c @@ -17,7 +17,7 @@ int dp_nat_get_used_ports_telemetry(struct rte_tel_data *dict) if (port->is_pf || !port->allocated) continue; - ret = rte_tel_data_add_dict_u64(dict, port->vm.machineid, port->stats.nat_stats.used_port_cnt); + ret = rte_tel_data_add_dict_u64(dict, port->iface.id, port->stats.nat_stats.used_port_cnt); if (DP_FAILED(ret)) { DPS_LOG_ERR("Failed to add interface used nat port telemetry data", DP_LOG_PORT(port), DP_LOG_RET(ret)); return ret; diff --git a/src/dp_lb.c b/src/dp_lb.c index 8a8c6ae3a..a3a8c1561 100644 --- a/src/dp_lb.c +++ b/src/dp_lb.c @@ -150,10 +150,10 @@ bool dp_is_lb_enabled(void) return rte_hash_count(ipv4_lb_tbl) > 0; } -bool dp_is_ip_lb(uint32_t vm_ip, uint32_t vni) +bool dp_is_ip_lb(uint32_t ol_ip, uint32_t vni) { struct lb_key nkey = { - .ip = vm_ip, + .ip = ol_ip, .vni = vni }; @@ -223,11 +223,11 @@ static int dp_lb_rr_backend(struct lb_value *val, const struct lb_port *lb_port) return ret; } -uint8_t *dp_lb_get_backend_ip(uint32_t v_ip, uint32_t vni, rte_be16_t port, uint8_t proto) +uint8_t *dp_lb_get_backend_ip(uint32_t ol_ip, uint32_t vni, rte_be16_t port, uint8_t proto) { struct lb_value *lb_val = NULL; struct lb_key nkey = { - .ip = v_ip, + .ip = ol_ip, .vni = vni }; struct lb_port lb_port; diff --git a/src/dp_lpm.c b/src/dp_lpm.c index 458c84b86..8876b0c9b 100644 --- a/src/dp_lpm.c +++ b/src/dp_lpm.c @@ -17,11 +17,11 @@ static __rte_always_inline int dp_lpm_fill_route_tables(const struct dp_port *po { int ret; - ret = dp_add_route(port, port->vm.vni, 0, port->vm.info.own_ip, NULL, 32); + ret = dp_add_route(port, port->iface.vni, 0, port->iface.cfg.own_ip, NULL, 32); if (DP_FAILED(ret)) return ret; - ret = dp_add_route6(port, port->vm.vni, 0, port->vm.info.dhcp_ipv6, NULL, 128); + ret = dp_add_route6(port, port->iface.vni, 0, port->iface.cfg.dhcp_ipv6, NULL, 128); if (DP_FAILED(ret)) return ret; @@ -37,7 +37,7 @@ int dp_lpm_reset_all_route_tables(void) return DP_GRPC_ERR_ROUTE_RESET; DP_FOREACH_PORT(ports, port) { - if (!port->vm.ready) + if (!port->iface.ready) continue; ret = dp_lpm_fill_route_tables(port); if (DP_FAILED(ret)) @@ -59,7 +59,7 @@ int dp_lpm_reset_route_tables(int vni) DP_FOREACH_PORT(ports, port) { // TODO(plague?): the cast does not seem nice, define a type for VNIs? - if (!port->vm.ready || (int)port->vm.vni != vni) + if (!port->iface.ready || (int)port->iface.vni != vni) continue; ret = dp_lpm_fill_route_tables(port); if (DP_FAILED(ret)) @@ -82,7 +82,7 @@ const uint8_t *dp_get_gw_ip6(void) int dp_add_route(const struct dp_port *port, uint32_t vni, uint32_t t_vni, uint32_t ip, const uint8_t *ip6, uint8_t depth) { - struct vm_route *route = NULL; + struct dp_iface_route *route = NULL; struct rte_rib_node *node; struct rte_rib *root; @@ -142,7 +142,7 @@ static __rte_always_inline bool dp_route_in_dhcp_range(const struct rte_rib_node // both calls only fail when either param is NULL rte_rib_get_ip(node, &ipv4); rte_rib_get_depth(node, &depth); - return port->vm.info.own_ip == ipv4 && depth == DP_LPM_DHCP_IP_DEPTH; + return port->iface.cfg.own_ip == ipv4 && depth == DP_LPM_DHCP_IP_DEPTH; } static int dp_list_route_entry(struct rte_rib_node *node, @@ -153,7 +153,7 @@ static int dp_list_route_entry(struct rte_rib_node *node, struct dpgrpc_route *reply; uint64_t next_hop; struct dp_port *dst_port; - struct vm_route *vm_route; + struct dp_iface_route *route; uint32_t ipv4; uint8_t depth; @@ -178,10 +178,10 @@ static int dp_list_route_entry(struct rte_rib_node *node, reply->pfx_length = depth; if (ext_routes) { - vm_route = (struct vm_route *)rte_rib_get_ext(node); + route = (struct dp_iface_route *)rte_rib_get_ext(node); reply->trgt_addr.ip_type = RTE_ETHER_TYPE_IPV6; - reply->trgt_vni = vm_route->vni; - rte_memcpy(reply->trgt_addr.ipv6, vm_route->nh_ipv6, sizeof(reply->trgt_addr.ipv6)); + reply->trgt_vni = route->vni; + rte_memcpy(reply->trgt_addr.ipv6, route->nh_ipv6, sizeof(reply->trgt_addr.ipv6)); } } @@ -221,7 +221,7 @@ int dp_list_routes(const struct dp_port *port, int vni, bool ext_routes, int dp_add_route6(const struct dp_port *port, uint32_t vni, uint32_t t_vni, const uint8_t *ipv6, const uint8_t *ext_ip6, uint8_t depth) { - struct vm_route *route = NULL; + struct dp_iface_route *route = NULL; struct rte_rib6_node *node; struct rte_rib6 *root; @@ -272,10 +272,10 @@ int dp_del_route6(const struct dp_port *port, uint32_t vni, const uint8_t *ipv6, return DP_GRPC_OK; } -const struct dp_port *dp_get_ip4_dst_port(const struct dp_port *port, +const struct dp_port *dp_get_ip4_out_port(const struct dp_port *in_port, int t_vni, const struct dp_flow *df, - struct vm_route *route, + struct dp_iface_route *route, uint32_t *route_key) { uint32_t dst_ip = ntohl(df->dst.dst_addr); @@ -285,7 +285,7 @@ const struct dp_port *dp_get_ip4_dst_port(const struct dp_port *port, struct dp_port *dst_port; if (t_vni == 0) - t_vni = port->vm.vni; + t_vni = in_port->iface.vni; root = dp_get_vni_route4_table(t_vni); if (!root) @@ -303,7 +303,7 @@ const struct dp_port *dp_get_ip4_dst_port(const struct dp_port *port, return NULL; if (dst_port->is_pf) - *route = *(struct vm_route *)rte_rib_get_ext(node); + *route = *(struct dp_iface_route *)rte_rib_get_ext(node); if (DP_FAILED(rte_rib_get_ip(node, route_key))) return NULL; @@ -311,10 +311,10 @@ const struct dp_port *dp_get_ip4_dst_port(const struct dp_port *port, return dst_port; } -const struct dp_port *dp_get_ip6_dst_port(const struct dp_port *port, +const struct dp_port *dp_get_ip6_out_port(const struct dp_port *in_port, int t_vni, const struct rte_ipv6_hdr *ipv6_hdr, - struct vm_route *route) + struct dp_iface_route *route) { struct rte_rib6_node *node; struct rte_rib6 *root; @@ -322,7 +322,7 @@ const struct dp_port *dp_get_ip6_dst_port(const struct dp_port *port, struct dp_port *dst_port; if (t_vni == 0) - t_vni = port->vm.vni; + t_vni = in_port->iface.vni; root = dp_get_vni_route6_table(t_vni); if (!root) @@ -340,7 +340,7 @@ const struct dp_port *dp_get_ip6_dst_port(const struct dp_port *port, return NULL; if (dst_port->is_pf) - *route = *(struct vm_route *)rte_rib6_get_ext(node); + *route = *(struct dp_iface_route *)rte_rib6_get_ext(node); return dst_port; } diff --git a/src/dp_nat.c b/src/dp_nat.c index 189e13fda..baec843c7 100644 --- a/src/dp_nat.c +++ b/src/dp_nat.c @@ -67,11 +67,11 @@ void dp_nat_free(void) dp_free_jhash_table(ipv4_snat_tbl); } -struct snat_data *dp_get_vm_snat_data(uint32_t vm_ip, uint32_t vni) +struct snat_data *dp_get_iface_snat_data(uint32_t iface_ip, uint32_t vni) { struct snat_data *data; struct nat_key nkey = { - .ip = vm_ip, + .ip = iface_ip, .vni = vni }; int ret; @@ -86,11 +86,11 @@ struct snat_data *dp_get_vm_snat_data(uint32_t vm_ip, uint32_t vni) return data; } -static struct snat_data *dp_create_vm_snat_data(uint32_t vm_ip, uint32_t vni) +static struct snat_data *dp_create_snat_data(uint32_t iface_ip, uint32_t vni) { struct snat_data *data; struct nat_key nkey = { - .ip = vm_ip, + .ip = iface_ip, .vni = vni }; @@ -106,10 +106,10 @@ static struct snat_data *dp_create_vm_snat_data(uint32_t vm_ip, uint32_t vni) return data; } -static void dp_delete_vm_snat_data(uint32_t vm_ip, uint32_t vni, struct snat_data *data) +static void dp_delete_snat_data(uint32_t iface_ip, uint32_t vni, struct snat_data *data) { struct nat_key nkey = { - .ip = vm_ip, + .ip = iface_ip, .vni = vni }; @@ -118,78 +118,79 @@ static void dp_delete_vm_snat_data(uint32_t vm_ip, uint32_t vni, struct snat_dat DPS_LOG_WARNING("Failed to delete SNAT key"); } -int dp_set_vm_snat_ip(uint32_t vm_ip, uint32_t s_ip, uint32_t vni, const uint8_t ul_ipv6[DP_VNF_IPV6_ADDR_SIZE]) +int dp_set_iface_vip_ip(uint32_t iface_ip, uint32_t vip_ip, uint32_t vni, + const uint8_t ul_ipv6[DP_VNF_IPV6_ADDR_SIZE]) { struct snat_data *data; - data = dp_get_vm_snat_data(vm_ip, vni); + data = dp_get_iface_snat_data(iface_ip, vni); if (!data) { - data = dp_create_vm_snat_data(vm_ip, vni); + data = dp_create_snat_data(iface_ip, vni); if (!data) return DP_GRPC_ERR_SNAT_CREATE; } else if (data->vip_ip != 0) return DP_GRPC_ERR_SNAT_EXISTS; - data->vip_ip = s_ip; - rte_memcpy(data->ul_ip6, ul_ipv6, sizeof(data->ul_ip6)); + data->vip_ip = vip_ip; + rte_memcpy(data->ul_vip_ip6, ul_ipv6, sizeof(data->ul_vip_ip6)); return DP_GRPC_OK; } -int dp_set_vm_network_snat_ip(uint32_t vm_ip, uint32_t s_ip, uint32_t vni, uint16_t min_port, - uint16_t max_port, const uint8_t ul_ipv6[DP_VNF_IPV6_ADDR_SIZE]) +int dp_set_iface_nat_ip(uint32_t iface_ip, uint32_t nat_ip, uint32_t vni, uint16_t min_port, uint16_t max_port, + const uint8_t ul_ipv6[DP_VNF_IPV6_ADDR_SIZE]) { struct snat_data *data; - data = dp_get_vm_snat_data(vm_ip, vni); + data = dp_get_iface_snat_data(iface_ip, vni); if (!data) { - data = dp_create_vm_snat_data(vm_ip, vni); + data = dp_create_snat_data(iface_ip, vni); if (!data) return DP_GRPC_ERR_SNAT_CREATE; - } else if (data->network_nat_ip != 0) + } else if (data->nat_ip != 0) return DP_GRPC_ERR_SNAT_EXISTS; - rte_memcpy(data->ul_nat_ip6, ul_ipv6, sizeof(data->ul_ip6)); - data->network_nat_ip = s_ip; - data->network_nat_port_range[0] = min_port; - data->network_nat_port_range[1] = max_port; + rte_memcpy(data->ul_nat_ip6, ul_ipv6, sizeof(data->ul_vip_ip6)); + data->nat_ip = nat_ip; + data->nat_port_range[0] = min_port; + data->nat_port_range[1] = max_port; return DP_GRPC_OK; } -int dp_del_vm_snat_ip(uint32_t vm_ip, uint32_t vni) +int dp_del_iface_vip_ip(uint32_t iface_ip, uint32_t vni) { struct snat_data *data; - data = dp_get_vm_snat_data(vm_ip, vni); + data = dp_get_iface_snat_data(iface_ip, vni); if (!data) return DP_GRPC_ERR_SNAT_NO_DATA; // NAT stil present, keep the data - if (data->network_nat_ip != 0) { + if (data->nat_ip != 0) { data->vip_ip = 0; return DP_GRPC_OK; } - dp_delete_vm_snat_data(vm_ip, vni, data); + dp_delete_snat_data(iface_ip, vni, data); return DP_GRPC_OK; } -int dp_del_vm_network_snat_ip(uint32_t vm_ip, uint32_t vni) +int dp_del_iface_nat_ip(uint32_t iface_ip, uint32_t vni) { struct snat_data *data; - data = dp_get_vm_snat_data(vm_ip, vni); + data = dp_get_iface_snat_data(iface_ip, vni); if (!data) return DP_GRPC_ERR_SNAT_NO_DATA; // VIP stil present, keep the data if (data->vip_ip != 0) { - data->network_nat_ip = 0; - data->network_nat_port_range[0] = 0; - data->network_nat_port_range[1] = 0; + data->nat_ip = 0; + data->nat_port_range[0] = 0; + data->nat_port_range[1] = 0; return DP_GRPC_OK; } - dp_delete_vm_snat_data(vm_ip, vni, data); + dp_delete_snat_data(iface_ip, vni, data); return DP_GRPC_OK; } @@ -422,18 +423,18 @@ int dp_allocate_network_snat_port(struct snat_data *snat_data, struct dp_flow *d struct netnat_portmap_key portmap_key; struct netnat_portmap_data *portmap_data; uint16_t min_port, max_port, allocated_port = 0, tmp_port; - uint32_t vm_src_info_hash; + uint32_t iface_src_info_hash; int ret; bool need_to_find_new_port = true; - uint32_t vm_ip = ntohl(df->src.src_addr); - uint16_t vm_port = ntohs(df->l4_info.trans_port.src_port); + uint32_t iface_src_ip = ntohl(df->src.src_addr); + uint16_t iface_src_port = ntohs(df->l4_info.trans_port.src_port); uint64_t timestamp; - portmap_key.vm_src_ip = vm_ip; + portmap_key.iface_src_ip = iface_src_ip; portmap_key.vni = vni; - portmap_key.vm_src_port = vm_port; + portmap_key.iface_src_port = iface_src_port; - portoverload_tbl_key.nat_ip = snat_data->network_nat_ip; + portoverload_tbl_key.nat_ip = snat_data->nat_ip; portoverload_tbl_key.dst_ip = ntohl(df->dst.dst_addr); portoverload_tbl_key.dst_port = ntohs(df->l4_info.trans_port.dst_port); portoverload_tbl_key.l4_type = df->l4_type; @@ -459,13 +460,13 @@ int dp_allocate_network_snat_port(struct snat_data *snat_data, struct dp_flow *d } if (need_to_find_new_port) { - min_port = snat_data->network_nat_port_range[0]; - max_port = snat_data->network_nat_port_range[1]; + min_port = snat_data->nat_port_range[0]; + max_port = snat_data->nat_port_range[1]; - vm_src_info_hash = (uint32_t)rte_hash_hash(ipv4_netnat_portmap_tbl, &portmap_key); + iface_src_info_hash = (uint32_t)rte_hash_hash(ipv4_netnat_portmap_tbl, &portmap_key); for (uint16_t p = 0; p < max_port - min_port; p++) { - tmp_port = min_port + (uint16_t)((vm_src_info_hash + p) % (uint32_t)(max_port - min_port)); + tmp_port = min_port + (uint16_t)((iface_src_info_hash + p) % (uint32_t)(max_port - min_port)); portoverload_tbl_key.nat_port = tmp_port; ret = rte_hash_lookup(ipv4_netnat_portoverload_tbl, &portoverload_tbl_key); if (ret == -ENOENT) { @@ -484,9 +485,9 @@ int dp_allocate_network_snat_port(struct snat_data *snat_data, struct dp_flow *d if (timestamp > snat_data->log_timestamp + dp_nat_full_log_delay) { snat_data->log_timestamp = timestamp; DPS_LOG_WARNING("NAT portmap range is full", - DP_LOG_IPV4(snat_data->network_nat_ip), - DP_LOG_VNI(vni), DP_LOG_SRC_IPV4(vm_ip), - DP_LOG_SRC_PORT(vm_port)); + DP_LOG_IPV4(snat_data->nat_ip), + DP_LOG_VNI(vni), DP_LOG_SRC_IPV4(iface_src_ip), + DP_LOG_SRC_PORT(iface_src_port)); } return DP_ERROR; } @@ -501,7 +502,7 @@ int dp_allocate_network_snat_port(struct snat_data *snat_data, struct dp_flow *d if (need_to_find_new_port) { portmap_data = rte_zmalloc("netnat_portmap_val", sizeof(struct netnat_portmap_data), RTE_CACHE_LINE_SIZE); - portmap_data->nat_ip = snat_data->network_nat_ip; + portmap_data->nat_ip = snat_data->nat_ip; portmap_data->nat_port = allocated_port; portmap_data->flow_cnt++; @@ -535,8 +536,8 @@ int dp_remove_network_snat_port(const struct flow_value *cntrack) if (DP_FAILED(ret) && ret != -ENOENT) return ret; - portmap_key.vm_src_ip = cntrack->flow_key[DP_FLOW_DIR_ORG].ip_src; - portmap_key.vm_src_port = cntrack->flow_key[DP_FLOW_DIR_ORG].src.port_src; + portmap_key.iface_src_ip = cntrack->flow_key[DP_FLOW_DIR_ORG].ip_src; + portmap_key.iface_src_port = cntrack->flow_key[DP_FLOW_DIR_ORG].src.port_src; portmap_key.vni = cntrack->nf_info.vni; ret = rte_hash_lookup_data(ipv4_netnat_portmap_tbl, &portmap_key, (void **)&portmap_data); @@ -580,12 +581,12 @@ int dp_list_nat_local_entries(uint32_t nat_ip, struct dp_grpc_responder *respond if (DP_FAILED(ret)) return DP_GRPC_ERR_ITERATOR; - if (data->network_nat_ip == nat_ip) { + if (data->nat_ip == nat_ip) { reply = dp_grpc_add_reply(responder); if (!reply) return DP_GRPC_ERR_OUT_OF_MEMORY; - reply->min_port = data->network_nat_port_range[0]; - reply->max_port = data->network_nat_port_range[1]; + reply->min_port = data->nat_port_range[0]; + reply->max_port = data->nat_port_range[1]; reply->addr.ip_type = RTE_ETHER_TYPE_IPV4; reply->addr.ipv4 = nkey->ip; reply->vni = nkey->vni; diff --git a/src/dp_periodic_msg.c b/src/dp_periodic_msg.c index a1707874a..8291b7de5 100644 --- a/src/dp_periodic_msg.c +++ b/src/dp_periodic_msg.c @@ -5,7 +5,7 @@ #include "dp_mbuf_dyn.h" #include "dp_periodic_msg.h" #include "dp_port.h" -#include "dp_vm.h" +#include "dp_iface.h" #include "nodes/arp_node.h" #include "nodes/ipv6_nd_node.h" @@ -21,7 +21,6 @@ void send_to_all_vfs(const struct rte_mbuf *pkt, uint16_t eth_type) struct dp_dpdk_layer *dp_layer = get_dpdk_layer(); const struct dp_ports *ports = dp_get_ports(); struct rte_mbuf *clone_buf; - const struct rte_ether_addr *mac; int ret; DP_FOREACH_PORT(ports, port) { @@ -37,14 +36,13 @@ void send_to_all_vfs(const struct rte_mbuf *pkt, uint16_t eth_type) clone_buf->port = port->port_id; eth_hdr = rte_pktmbuf_mtod(clone_buf, struct rte_ether_hdr *); - mac = &port->vm.info.own_mac; - rte_ether_addr_copy(mac, ð_hdr->src_addr); + rte_ether_addr_copy(&port->own_mac, ð_hdr->src_addr); if (eth_type == RTE_ETHER_TYPE_ARP) { arp_hdr = (struct rte_arp_hdr *)(eth_hdr + 1); - rte_ether_addr_copy(mac, &arp_hdr->arp_data.arp_sha); + rte_ether_addr_copy(&port->own_mac, &arp_hdr->arp_data.arp_sha); if (dp_arp_cycle_needed(port)) - arp_hdr->arp_data.arp_tip = htonl(port->vm.info.own_ip); + arp_hdr->arp_data.arp_tip = htonl(port->iface.cfg.own_ip); } dp_init_pkt_mark(clone_buf); diff --git a/src/dp_port.c b/src/dp_port.c index 5a9765ad5..d70740f9d 100644 --- a/src/dp_port.c +++ b/src/dp_port.c @@ -147,9 +147,9 @@ static int dp_port_init_ethdev(struct dp_port *port, struct rte_eth_dev_info *de rte_eth_dev_get_name_by_port(port->port_id, port->dev_name); if (port->is_pf) { - if (DP_FAILED(dp_get_pf_neigh_mac(dev_info->if_index, &pf_neigh_mac, &port->vm.info.own_mac))) + if (DP_FAILED(dp_get_pf_neigh_mac(dev_info->if_index, &pf_neigh_mac, &port->own_mac))) return DP_ERROR; - rte_ether_addr_copy(&pf_neigh_mac, &port->vm.info.neigh_mac); + rte_ether_addr_copy(&pf_neigh_mac, &port->neigh_mac); } return DP_OK; diff --git a/src/dp_service.c b/src/dp_service.c index 67ed02c52..7f138465e 100644 --- a/src/dp_service.c +++ b/src/dp_service.c @@ -11,7 +11,7 @@ #include "dp_graph.h" #include "dp_lb.h" #include "dp_log.h" -#include "dp_vm.h" +#include "dp_iface.h" #include "dp_multi_path.h" #include "dp_nat.h" #include "dp_port.h" @@ -165,10 +165,10 @@ static int init_interfaces(void) // VFs are started by GRPC later if (DP_FAILED(dp_flow_init(pf0_socket_id)) + || DP_FAILED(dp_ifaces_init(pf0_socket_id)) || DP_FAILED(dp_nat_init(pf0_socket_id)) || DP_FAILED(dp_lb_init(pf0_socket_id)) || DP_FAILED(dp_vni_init(pf0_socket_id)) - || DP_FAILED(dp_vms_init(pf0_socket_id)) || DP_FAILED(dp_vnf_init(pf0_socket_id))) return DP_ERROR; @@ -178,10 +178,10 @@ static int init_interfaces(void) static void free_interfaces(void) { dp_vnf_free(); - dp_vms_free(); dp_vni_free(); dp_lb_free(); dp_nat_free(); + dp_ifaces_free(); dp_flow_free(); dp_telemetry_free(); dp_graph_free(); diff --git a/src/dp_virtsvc.c b/src/dp_virtsvc.c index 43d5f40e0..fb1a7d4dc 100644 --- a/src/dp_virtsvc.c +++ b/src/dp_virtsvc.c @@ -352,7 +352,7 @@ int dp_virtsvc_get_pf_route(struct dp_virtsvc *virtsvc, } -void dp_virtsvc_del_vm(uint16_t port_id) +void dp_virtsvc_del_iface(uint16_t port_id) { struct dp_virtsvc_conn_key delete_key; struct dp_virtsvc_conn *conn; diff --git a/src/dp_vm.c b/src/dp_vm.c deleted file mode 100644 index 4a317f75a..000000000 --- a/src/dp_vm.c +++ /dev/null @@ -1,94 +0,0 @@ -#include "dp_vm.h" -#include "dp_vni.h" - -static struct rte_hash *vm_handle_tbl = NULL; - -int dp_vms_init(int socket_id) -{ - vm_handle_tbl = dp_create_jhash_table(DP_MAX_PORTS, VM_IFACE_ID_MAX_LEN, - "vm_handle_table", socket_id); - if (!vm_handle_tbl) - return DP_ERROR; - - return DP_OK; -} - -void dp_vms_free(void) -{ - dp_free_jhash_table(vm_handle_tbl); -} - -int dp_map_vm_handle(const char key[VM_IFACE_ID_MAX_LEN], struct dp_port *port) -{ - hash_sig_t hash = rte_hash_hash(vm_handle_tbl, key); - int ret; - - ret = rte_hash_lookup_with_hash(vm_handle_tbl, key, hash); - if (ret != -ENOENT) { - if (DP_FAILED(ret)) - DPS_LOG_ERR("VM handle lookup failed", DP_LOG_RET(ret)); - else - DPS_LOG_ERR("VM handle already exists"); - return DP_ERROR; - } - - ret = rte_hash_add_key_with_hash_data(vm_handle_tbl, key, hash, port); - if (DP_FAILED(ret)) { - DPS_LOG_ERR("Cannot add VM handle data", DP_LOG_PORT(port), DP_LOG_RET(ret)); - return DP_ERROR; - } - - static_assert(sizeof(port->vm.machineid) == VM_IFACE_ID_MAX_LEN, "Incompatible VM ID size"); - rte_memcpy(port->vm.machineid, key, VM_IFACE_ID_MAX_LEN); - - return DP_OK; -} - -void dp_unmap_vm_handle(const void *key) -{ - rte_hash_del_key(vm_handle_tbl, key); -} - -struct dp_port *dp_get_port_with_vm_handle(const void *key) -{ - struct dp_port *port; - int ret; - - ret = rte_hash_lookup_data(vm_handle_tbl, key, (void **)&port); - if (DP_FAILED(ret)) { - if (ret != -ENOENT) - DPS_LOG_ERR("Failed to look the VM port-id up", DP_LOG_RET(ret)); - return NULL; - } - - return port; -} - - -int dp_setup_vm(struct dp_port *port, int vni) -{ - if (DP_FAILED(dp_create_vni_route_tables(vni, port->socket_id))) - return DP_ERROR; - - dp_init_firewall_rules(port); - port->vm.vni = vni; - port->vm.ready = 1; - return DP_OK; -} - -void dp_del_vm(struct dp_port *port) -{ - uint32_t vni = port->vm.vni; - - dp_del_route(port, vni, port->vm.info.own_ip, 32); - dp_del_route6(port, vni, port->vm.info.dhcp_ipv6, 128); - - if (DP_FAILED(dp_delete_vni_route_tables(vni))) - DPS_LOG_WARNING("Unable to delete route tables", DP_LOG_VNI(vni)); - - dp_del_all_firewall_rules(port); - - memset(&port->vm, 0, sizeof(port->vm)); - // own mac address in the vm_entry needs to be refilled due to the above cleaning process - dp_load_mac(port); -} diff --git a/src/dp_vnf.c b/src/dp_vnf.c index a73542817..7d9852794 100644 --- a/src/dp_vnf.c +++ b/src/dp_vnf.c @@ -53,7 +53,7 @@ int dp_get_vnf_entry(struct dp_vnf_value *val, enum vnf_type v_type, const struc { val->v_type = v_type; val->portid = match_all ? DP_VNF_MATCH_ALL_PORT_ID_VALUE : port->port_id; - val->vni = port->vm.vni; + val->vni = port->iface.vni; return dp_find_vnf_with_value(val); } diff --git a/src/dp_vni.c b/src/dp_vni.c index 0f18545ca..e0eb6572b 100644 --- a/src/dp_vni.c +++ b/src/dp_vni.c @@ -68,7 +68,7 @@ static __rte_always_inline int dp_create_rib6(uint32_t vni, int socket_id, struc char s[64]; config_ipv6.max_nodes = IPV6_DP_RIB_MAX_RULES; - config_ipv6.ext_sz = sizeof(struct vm_route); + config_ipv6.ext_sz = sizeof(struct dp_iface_route); snprintf(s, sizeof(s), "IPV6_DP_RIB_%d_%d", vni, socket_id); new_rib6 = rte_rib6_create(s, socket_id, &config_ipv6); @@ -90,7 +90,7 @@ static __rte_always_inline int dp_create_rib(uint32_t vni, int socket_id, struct char s[64]; config_ipv4.max_nodes = IPV4_DP_RIB_MAX_RULES; - config_ipv4.ext_sz = sizeof(struct vm_route); + config_ipv4.ext_sz = sizeof(struct dp_iface_route); snprintf(s, sizeof(s), "IPV4_DP_RIB_%d_%d", vni, socket_id); new_rib = rte_rib_create(s, socket_id, &config_ipv4); diff --git a/src/grpc/dp_grpc_impl.c b/src/grpc/dp_grpc_impl.c index 5c8c4cb2b..58c7e1383 100644 --- a/src/grpc/dp_grpc_impl.c +++ b/src/grpc/dp_grpc_impl.c @@ -11,7 +11,7 @@ #ifdef ENABLE_VIRTSVC # include "dp_virtsvc.h" #endif -#include "dp_vm.h" +#include "dp_iface.h" #include "dp_vnf.h" #include "dp_vni.h" #include "dpdk_layer.h" @@ -69,7 +69,7 @@ static __rte_always_inline int dp_remove_vnf_entry(struct dp_vnf_value *val, enu { val->v_type = v_type; val->portid = port->port_id; - val->vni = port->vm.vni; + val->vni = port->iface.vni; return dp_del_vnf_with_value(val); } @@ -185,7 +185,7 @@ static int dp_process_create_fwrule(struct dp_grpc_responder *responder) struct dpgrpc_fwrule *request = &responder->request.add_fwrule; struct dp_port *port; - port = dp_get_port_with_vm_handle(request->iface_id); + port = dp_get_port_with_iface_id(request->iface_id); if (!port) return DP_GRPC_ERR_NO_VM; @@ -209,7 +209,7 @@ static int dp_process_get_fwrule(struct dp_grpc_responder *responder) struct dp_port *port; struct dp_fwall_rule *rule; - port = dp_get_port_with_vm_handle(request->iface_id); + port = dp_get_port_with_iface_id(request->iface_id); if (!port) return DP_GRPC_ERR_NO_VM; @@ -226,7 +226,7 @@ static int dp_process_delete_fwrule(struct dp_grpc_responder *responder) struct dpgrpc_fwrule_id *request = &responder->request.del_fwrule; struct dp_port *port; - port = dp_get_port_with_vm_handle(request->iface_id); + port = dp_get_port_with_iface_id(request->iface_id); if (!port) return DP_GRPC_ERR_NO_VM; @@ -254,29 +254,29 @@ static int dp_process_create_vip(struct dp_grpc_responder *responder) uint8_t ul_addr6[DP_VNF_IPV6_ADDR_SIZE]; struct dp_vnf_value vnf_val = {0}; struct dp_port *port; - uint32_t vm_ip, vm_vni; + uint32_t iface_ip, iface_vni; uint32_t vip; int ret; - port = dp_get_port_with_vm_handle(request->iface_id); + port = dp_get_port_with_iface_id(request->iface_id); if (!port) { ret = DP_GRPC_ERR_NO_VM; goto err; } if (request->addr.ip_type == RTE_ETHER_TYPE_IPV4) { - vm_ip = port->vm.info.own_ip; - vm_vni = port->vm.vni; - if (DP_FAILED(dp_insert_vnf_entry(&vnf_val, DP_VNF_TYPE_VIP, vm_vni, port, ul_addr6))) { + iface_ip = port->iface.cfg.own_ip; + iface_vni = port->iface.vni; + if (DP_FAILED(dp_insert_vnf_entry(&vnf_val, DP_VNF_TYPE_VIP, iface_vni, port, ul_addr6))) { ret = DP_GRPC_ERR_VNF_INSERT; goto err; } vip = request->addr.ipv4; - ret = dp_set_vm_snat_ip(vm_ip, vip, vm_vni, ul_addr6); + ret = dp_set_iface_vip_ip(iface_ip, vip, iface_vni, ul_addr6); if (DP_FAILED(ret)) goto err_vnf; - ret = dp_set_dnat_ip(vip, vm_ip, vm_vni); + ret = dp_set_dnat_ip(vip, iface_ip, iface_vni); if (DP_FAILED(ret)) goto err_snat; @@ -288,7 +288,7 @@ static int dp_process_create_vip(struct dp_grpc_responder *responder) return DP_GRPC_OK; err_snat: - dp_del_vm_snat_ip(vm_ip, vm_vni); + dp_del_iface_vip_ip(iface_ip, iface_vni); err_vnf: dp_del_vnf_with_vnf_key(ul_addr6); err: @@ -302,28 +302,28 @@ static int dp_process_delete_vip(struct dp_grpc_responder *responder) struct dp_port *port; struct snat_data *s_data; - uint32_t vm_ip, vm_vni; + uint32_t iface_ip, iface_vni; - port = dp_get_port_with_vm_handle(request->iface_id); + port = dp_get_port_with_iface_id(request->iface_id); if (!port) return DP_GRPC_ERR_NO_VM; - vm_ip = port->vm.info.own_ip; - vm_vni = port->vm.vni; + iface_ip = port->iface.cfg.own_ip; + iface_vni = port->iface.vni; - s_data = dp_get_vm_snat_data(vm_ip, vm_vni); + s_data = dp_get_iface_snat_data(iface_ip, iface_vni); if (!s_data || !s_data->vip_ip) return DP_GRPC_ERR_SNAT_NO_DATA; - dp_del_vnf_with_vnf_key(s_data->ul_ip6); + dp_del_vnf_with_vnf_key(s_data->ul_vip_ip6); reply->addr.ip_type = RTE_ETHER_TYPE_IPV4; reply->addr.ipv4 = s_data->vip_ip; // always delete, i.e. do not use dp_del_vip_from_dnat(), // because 1:1 VIP is not shared with anything - dp_del_dnat_ip(s_data->vip_ip, vm_vni); - dp_del_vm_snat_ip(vm_ip, vm_vni); + dp_del_dnat_ip(s_data->vip_ip, iface_vni); + dp_del_iface_vip_ip(iface_ip, iface_vni); dp_remove_nat_flows(port->port_id, DP_FLOW_NAT_TYPE_VIP); return DP_GRPC_OK; } @@ -336,17 +336,17 @@ static int dp_process_get_vip(struct dp_grpc_responder *responder) struct dp_port *port; struct snat_data *s_data; - port = dp_get_port_with_vm_handle(request->iface_id); + port = dp_get_port_with_iface_id(request->iface_id); if (!port) return DP_GRPC_ERR_NO_VM; - s_data = dp_get_vm_snat_data(port->vm.info.own_ip, port->vm.vni); + s_data = dp_get_iface_snat_data(port->iface.cfg.own_ip, port->iface.vni); if (!s_data || !s_data->vip_ip) return DP_GRPC_ERR_SNAT_NO_DATA; reply->addr.ip_type = RTE_ETHER_TYPE_IPV4; reply->addr.ipv4 = s_data->vip_ip; - rte_memcpy(reply->ul_addr6, s_data->ul_ip6, sizeof(reply->ul_addr6)); + rte_memcpy(reply->ul_addr6, s_data->ul_vip_ip6, sizeof(reply->ul_addr6)); return DP_GRPC_OK; } @@ -365,14 +365,14 @@ static int dp_process_create_lbprefix(struct dp_grpc_responder *responder) if (request->addr.ip_type != RTE_ETHER_TYPE_IPV4) return DP_GRPC_ERR_BAD_IPVER; - port = dp_get_port_with_vm_handle(request->iface_id); + port = dp_get_port_with_iface_id(request->iface_id); if (!port) return DP_GRPC_ERR_NO_VM; if (!DP_FAILED(dp_get_vnf_entry(&vnf_val, DP_VNF_TYPE_LB_ALIAS_PFX, port, !DP_VNF_MATCH_ALL_PORT_ID))) return DP_GRPC_ERR_ALREADY_EXISTS; - if (DP_FAILED(dp_insert_vnf_entry(&vnf_val, DP_VNF_TYPE_LB_ALIAS_PFX, port->vm.vni, port, ul_addr6))) + if (DP_FAILED(dp_insert_vnf_entry(&vnf_val, DP_VNF_TYPE_LB_ALIAS_PFX, port->iface.vni, port, ul_addr6))) return DP_GRPC_ERR_VNF_INSERT; rte_memcpy(reply->trgt_addr.ipv6, ul_addr6, sizeof(reply->trgt_addr.ipv6)); @@ -392,7 +392,7 @@ static int dp_process_delete_lbprefix(struct dp_grpc_responder *responder) if (request->addr.ip_type != RTE_ETHER_TYPE_IPV4) return DP_GRPC_ERR_BAD_IPVER; - port = dp_get_port_with_vm_handle(request->iface_id); + port = dp_get_port_with_iface_id(request->iface_id); if (!port) return DP_GRPC_ERR_NO_VM; @@ -406,25 +406,25 @@ static int dp_process_create_prefix(struct dp_grpc_responder *responder) uint8_t ul_addr6[DP_VNF_IPV6_ADDR_SIZE]; struct dp_port *port; - uint32_t vm_vni; + uint32_t iface_vni; struct dp_vnf_value vnf_val = { .alias_pfx.ip = request->addr.ipv4, .alias_pfx.length = request->length, }; int ret; - port = dp_get_port_with_vm_handle(request->iface_id); + port = dp_get_port_with_iface_id(request->iface_id); if (!port) return DP_GRPC_ERR_NO_VM; if (request->addr.ip_type == RTE_ETHER_TYPE_IPV4) { - vm_vni = port->vm.vni; - ret = dp_add_route(port, vm_vni, 0, vnf_val.alias_pfx.ip, NULL, vnf_val.alias_pfx.length); + iface_vni = port->iface.vni; + ret = dp_add_route(port, iface_vni, 0, vnf_val.alias_pfx.ip, NULL, vnf_val.alias_pfx.length); if (DP_FAILED(ret)) return ret; - if (DP_FAILED(dp_insert_vnf_entry(&vnf_val, DP_VNF_TYPE_ALIAS_PFX, vm_vni, port, ul_addr6))) { - dp_del_route(port, vm_vni, vnf_val.alias_pfx.ip, vnf_val.alias_pfx.length); + if (DP_FAILED(dp_insert_vnf_entry(&vnf_val, DP_VNF_TYPE_ALIAS_PFX, iface_vni, port, ul_addr6))) { + dp_del_route(port, iface_vni, vnf_val.alias_pfx.ip, vnf_val.alias_pfx.length); return DP_GRPC_ERR_VNF_INSERT; } rte_memcpy(reply->addr6, ul_addr6, sizeof(reply->addr6)); @@ -445,12 +445,12 @@ static int dp_process_delete_prefix(struct dp_grpc_responder *responder) }; int ret, ret2; - port = dp_get_port_with_vm_handle(request->iface_id); + port = dp_get_port_with_iface_id(request->iface_id); if (!port) return DP_GRPC_ERR_NO_VM; if (request->addr.ip_type == RTE_ETHER_TYPE_IPV4) { - ret = dp_del_route(port, port->vm.vni, + ret = dp_del_route(port, port->iface.vni, vnf_val.alias_pfx.ip, vnf_val.alias_pfx.length); // ignore the error and try to delete the vnf entry anyway } else @@ -483,27 +483,27 @@ static int dp_process_create_interface(struct dp_grpc_responder *responder) ret = DP_GRPC_ERR_VNF_INSERT; goto err; } - if (DP_FAILED(dp_map_vm_handle(request->iface_id, port))) { + if (DP_FAILED(dp_map_iface_id(request->iface_id, port))) { ret = DP_GRPC_ERR_VM_HANDLE; goto err_vnf; } - if (DP_FAILED(dp_setup_vm(port, request->vni))) { + if (DP_FAILED(dp_setup_iface(port, request->vni))) { ret = DP_GRPC_ERR_VNI_INIT4; goto handle_err; } - rte_memcpy(port->vm.ul_ipv6, ul_addr6, sizeof(port->vm.ul_ipv6)); - port->vm.info.own_ip = request->ip4_addr; - port->vm.info.depth = DP_LPM_DHCP_IP_DEPTH; - rte_memcpy(port->vm.info.dhcp_ipv6, request->ip6_addr, sizeof(port->vm.info.dhcp_ipv6)); - port->vm.info.depth = DP_LPM_DHCP_IP6_DEPTH; - static_assert(sizeof(request->pxe_str) == sizeof(port->vm.info.pxe_str), "Incompatible VM PXE size"); - rte_memcpy(port->vm.info.pxe_str, request->pxe_str, sizeof(port->vm.info.pxe_str)); - port->vm.info.pxe_ip = request->ip4_pxe_addr; + rte_memcpy(port->iface.ul_ipv6, ul_addr6, sizeof(port->iface.ul_ipv6)); + port->iface.cfg.own_ip = request->ip4_addr; + port->iface.cfg.ip_depth = DP_LPM_DHCP_IP_DEPTH; + rte_memcpy(port->iface.cfg.dhcp_ipv6, request->ip6_addr, sizeof(port->iface.cfg.dhcp_ipv6)); + port->iface.cfg.ip6_depth = DP_LPM_DHCP_IP6_DEPTH; + static_assert(sizeof(request->pxe_str) == sizeof(port->iface.cfg.pxe_str), "Incompatible interface PXE size"); + rte_memcpy(port->iface.cfg.pxe_str, request->pxe_str, sizeof(port->iface.cfg.pxe_str)); + port->iface.cfg.pxe_ip = request->ip4_pxe_addr; ret = dp_add_route(port, request->vni, 0, request->ip4_addr, NULL, 32); if (DP_FAILED(ret)) - goto vm_err; + goto iface_err; ret = dp_add_route6(port, request->vni, 0, request->ip6_addr, NULL, 128); if (DP_FAILED(ret)) goto route_err; @@ -512,7 +512,7 @@ static int dp_process_create_interface(struct dp_grpc_responder *responder) goto route6_err; } - rte_memcpy(reply->ul_addr6, port->vm.ul_ipv6, sizeof(reply->ul_addr6)); + rte_memcpy(reply->ul_addr6, port->iface.ul_ipv6, sizeof(reply->ul_addr6)); snprintf(reply->name, sizeof(reply->name), "%s", port->vf_name); return DP_GRPC_OK; @@ -520,10 +520,10 @@ static int dp_process_create_interface(struct dp_grpc_responder *responder) dp_del_route6(port, request->vni, request->ip6_addr, 128); route_err: dp_del_route(port, request->vni, request->ip4_addr, 32); -vm_err: - dp_del_vm(port); +iface_err: + dp_delete_iface(port); handle_err: - dp_unmap_vm_handle(request->iface_id); + dp_unmap_iface_id(request->iface_id); err_vnf: dp_del_vnf_with_vnf_key(ul_addr6); err: @@ -539,23 +539,23 @@ static int dp_process_delete_interface(struct dp_grpc_responder *responder) uint32_t vni; int ret = DP_GRPC_OK; - port = dp_get_port_with_vm_handle(request->iface_id); + port = dp_get_port_with_iface_id(request->iface_id); if (!port) return DP_GRPC_ERR_NOT_FOUND; - ipv4 = port->vm.info.own_ip; - vni = port->vm.vni; + ipv4 = port->iface.cfg.own_ip; + vni = port->iface.vni; - dp_del_vnf_with_vnf_key(port->vm.ul_ipv6); + dp_del_vnf_with_vnf_key(port->iface.ul_ipv6); if (DP_FAILED(dp_stop_port(port))) ret = DP_GRPC_ERR_PORT_STOP; // carry on with cleanup though - dp_unmap_vm_handle(request->iface_id); - dp_del_vm(port); + dp_unmap_iface_id(request->iface_id); + dp_delete_iface(port); #ifdef ENABLE_VIRTSVC - dp_virtsvc_del_vm(port->port_id); + dp_virtsvc_del_iface(port->port_id); #endif - dp_remove_vm_flows(port->port_id, ipv4, vni); + dp_remove_iface_flows(port->port_id, ipv4, vni); return ret; } @@ -566,18 +566,18 @@ static int dp_process_get_interface(struct dp_grpc_responder *responder) struct dp_port *port; - port = dp_get_port_with_vm_handle(request->iface_id); + port = dp_get_port_with_iface_id(request->iface_id); if (!port) return DP_GRPC_ERR_NOT_FOUND; - reply->ip4_addr = port->vm.info.own_ip; - rte_memcpy(reply->ip6_addr, port->vm.info.dhcp_ipv6, sizeof(reply->ip6_addr)); - reply->vni = port->vm.vni; - static_assert(sizeof(reply->iface_id) == sizeof(port->vm.machineid), "Incompatible VM ID size"); - rte_memcpy(reply->iface_id, port->vm.machineid, sizeof(reply->iface_id)); + reply->ip4_addr = port->iface.cfg.own_ip; + rte_memcpy(reply->ip6_addr, port->iface.cfg.dhcp_ipv6, sizeof(reply->ip6_addr)); + reply->vni = port->iface.vni; + static_assert(sizeof(reply->iface_id) == sizeof(port->iface.id), "Incompatible VM ID size"); + rte_memcpy(reply->iface_id, port->iface.id, sizeof(reply->iface_id)); static_assert(sizeof(reply->pci_name) == sizeof(port->dev_name), "Incompatible PCI name size"); rte_memcpy(reply->pci_name, port->dev_name, sizeof(reply->pci_name)); - rte_memcpy(reply->ul_addr6, port->vm.ul_ipv6, sizeof(reply->ul_addr6)); + rte_memcpy(reply->ul_addr6, port->iface.ul_ipv6, sizeof(reply->ul_addr6)); return DP_GRPC_OK; } @@ -620,29 +620,29 @@ static int dp_process_create_nat(struct dp_grpc_responder *responder) uint8_t ul_addr6[DP_VNF_IPV6_ADDR_SIZE]; struct dp_vnf_value vnf_val = {0}; struct dp_port *port; - uint32_t vm_ip, vm_vni; + uint32_t iface_ip, iface_vni; int ret; - port = dp_get_port_with_vm_handle(request->iface_id); + port = dp_get_port_with_iface_id(request->iface_id); if (!port) { ret = DP_GRPC_ERR_NO_VM; goto err; } if (request->addr.ip_type == RTE_ETHER_TYPE_IPV4) { - vm_ip = port->vm.info.own_ip; - vm_vni = port->vm.vni; - if (DP_FAILED(dp_insert_vnf_entry(&vnf_val, DP_VNF_TYPE_NAT, vm_vni, port, ul_addr6))) { + iface_ip = port->iface.cfg.own_ip; + iface_vni = port->iface.vni; + if (DP_FAILED(dp_insert_vnf_entry(&vnf_val, DP_VNF_TYPE_NAT, iface_vni, port, ul_addr6))) { ret = DP_GRPC_ERR_VNF_INSERT; goto err; } - ret = dp_set_vm_network_snat_ip(vm_ip, request->addr.ipv4, vm_vni, + ret = dp_set_iface_nat_ip(iface_ip, request->addr.ipv4, iface_vni, request->min_port, request->max_port, ul_addr6); if (DP_FAILED(ret)) goto err_vnf; - ret = dp_set_dnat_ip(request->addr.ipv4, 0, vm_vni); + ret = dp_set_dnat_ip(request->addr.ipv4, 0, iface_vni); if (DP_FAILED(ret) && ret != DP_GRPC_ERR_DNAT_EXISTS) goto err_dnat; rte_memcpy(reply->addr6, ul_addr6, sizeof(reply->addr6)); @@ -653,7 +653,7 @@ static int dp_process_create_nat(struct dp_grpc_responder *responder) return DP_GRPC_OK; err_dnat: - dp_del_vm_network_snat_ip(vm_ip, vm_vni); + dp_del_iface_nat_ip(iface_ip, iface_vni); err_vnf: dp_del_vnf_with_vnf_key(ul_addr6); err: @@ -668,26 +668,26 @@ static int dp_process_delete_nat(struct dp_grpc_responder *responder) struct dp_port *port; struct snat_data *s_data; - uint32_t vm_ip, vm_vni; + uint32_t iface_ip, iface_vni; - port = dp_get_port_with_vm_handle(request->iface_id); + port = dp_get_port_with_iface_id(request->iface_id); if (!port) return DP_GRPC_ERR_NO_VM; - vm_ip = port->vm.info.own_ip; - vm_vni = port->vm.vni; + iface_ip = port->iface.cfg.own_ip; + iface_vni = port->iface.vni; - s_data = dp_get_vm_snat_data(vm_ip, vm_vni); - if (!s_data || !s_data->network_nat_ip) + s_data = dp_get_iface_snat_data(iface_ip, iface_vni); + if (!s_data || !s_data->nat_ip) return DP_GRPC_ERR_SNAT_NO_DATA; dp_del_vnf_with_vnf_key(s_data->ul_nat_ip6); reply->addr.ip_type = RTE_ETHER_TYPE_IPV4; - reply->addr.ipv4 = s_data->network_nat_ip; - dp_del_vip_from_dnat(s_data->network_nat_ip, vm_vni); + reply->addr.ipv4 = s_data->nat_ip; + dp_del_vip_from_dnat(s_data->nat_ip, iface_vni); dp_remove_nat_flows(port->port_id, DP_FLOW_NAT_TYPE_NETWORK_LOCAL); - return dp_del_vm_network_snat_ip(vm_ip, vm_vni); + return dp_del_iface_nat_ip(iface_ip, iface_vni); } static int dp_process_get_nat(struct dp_grpc_responder *responder) @@ -698,18 +698,18 @@ static int dp_process_get_nat(struct dp_grpc_responder *responder) struct dp_port *port; struct snat_data *s_data; - port = dp_get_port_with_vm_handle(request->iface_id); + port = dp_get_port_with_iface_id(request->iface_id); if (!port) return DP_GRPC_ERR_NO_VM; - s_data = dp_get_vm_snat_data(port->vm.info.own_ip, port->vm.vni); - if (!s_data || !s_data->network_nat_ip) + s_data = dp_get_iface_snat_data(port->iface.cfg.own_ip, port->iface.vni); + if (!s_data || !s_data->nat_ip) return DP_GRPC_ERR_SNAT_NO_DATA; reply->addr.ip_type = RTE_ETHER_TYPE_IPV4; - reply->addr.ipv4 = s_data->network_nat_ip; - reply->min_port = s_data->network_nat_port_range[0]; - reply->max_port = s_data->network_nat_port_range[1]; + reply->addr.ipv4 = s_data->nat_ip; + reply->min_port = s_data->nat_port_range[0]; + reply->max_port = s_data->nat_port_range[1]; rte_memcpy(reply->ul_addr6, s_data->ul_nat_ip6, sizeof(reply->ul_addr6)); return DP_GRPC_OK; } @@ -767,21 +767,21 @@ static int dp_process_list_interfaces(struct dp_grpc_responder *responder) dp_grpc_set_multireply(responder, sizeof(*reply)); DP_FOREACH_PORT(ports, port) { - if (!port->vm.ready) + if (!port->iface.ready) continue; reply = dp_grpc_add_reply(responder); if (!reply) return DP_GRPC_ERR_OUT_OF_MEMORY; - reply->ip4_addr = port->vm.info.own_ip; - rte_memcpy(reply->ip6_addr, port->vm.info.dhcp_ipv6, sizeof(reply->ip6_addr)); - reply->vni = port->vm.vni; - static_assert(sizeof(reply->iface_id) == sizeof(port->vm.machineid), "Incompatible VM ID size"); - rte_memcpy(reply->iface_id, port->vm.machineid, sizeof(reply->iface_id)); + reply->ip4_addr = port->iface.cfg.own_ip; + rte_memcpy(reply->ip6_addr, port->iface.cfg.dhcp_ipv6, sizeof(reply->ip6_addr)); + reply->vni = port->iface.vni; + static_assert(sizeof(reply->iface_id) == sizeof(port->iface.id), "Incompatible VM ID size"); + rte_memcpy(reply->iface_id, port->iface.id, sizeof(reply->iface_id)); static_assert(sizeof(reply->pci_name) == sizeof(port->dev_name), "Incompatible PCI name size"); rte_memcpy(reply->pci_name, port->dev_name, sizeof(reply->pci_name)); - rte_memcpy(reply->ul_addr6, port->vm.ul_ipv6, sizeof(reply->ul_addr6)); + rte_memcpy(reply->ul_addr6, port->iface.ul_ipv6, sizeof(reply->ul_addr6)); } return DP_GRPC_OK; @@ -802,7 +802,7 @@ static int dp_process_list_fwrules(struct dp_grpc_responder *responder) { struct dp_port *port; - port = dp_get_port_with_vm_handle(responder->request.list_fwrule.iface_id); + port = dp_get_port_with_iface_id(responder->request.list_fwrule.iface_id); if (!port) return DP_GRPC_ERR_NO_VM; @@ -813,7 +813,7 @@ static int dp_process_list_lbprefixes(struct dp_grpc_responder *responder) { struct dp_port *port; - port = dp_get_port_with_vm_handle(responder->request.list_lbpfx.iface_id); + port = dp_get_port_with_iface_id(responder->request.list_lbpfx.iface_id); if (!port) return DP_GRPC_ERR_NO_VM; @@ -824,7 +824,7 @@ static int dp_process_list_prefixes(struct dp_grpc_responder *responder) { struct dp_port *port; - port = dp_get_port_with_vm_handle(responder->request.list_pfx.iface_id); + port = dp_get_port_with_iface_id(responder->request.list_pfx.iface_id); if (!port) return DP_GRPC_ERR_NO_VM; @@ -883,7 +883,7 @@ static int dp_process_capture_start(struct dp_grpc_responder *responder) for (int i = 0; i < request->interface_count; ++i) { switch (request->interfaces[i].type) { case DP_CAPTURE_IFACE_TYPE_SINGLE_VF: - port = dp_get_port_with_vm_handle(request->interfaces[i].spec.iface_id); + port = dp_get_port_with_iface_id(request->interfaces[i].spec.iface_id); break; case DP_CAPTURE_IFACE_TYPE_SINGLE_PF: port = dp_get_port_by_pf_index(request->interfaces[i].spec.pf_index); @@ -959,9 +959,9 @@ static int dp_process_capture_status(struct dp_grpc_responder *responder) reply->interfaces[count].spec.pf_index = port == dp_get_pf0() ? 0 : 1; } else { reply->interfaces[count].type = DP_CAPTURE_IFACE_TYPE_SINGLE_VF; - static_assert(sizeof(reply->interfaces[count].spec.iface_id) == sizeof(port->vm.machineid), + static_assert(sizeof(reply->interfaces[count].spec.iface_id) == sizeof(port->iface.id), "Invalid size for captured interface id"); - rte_memcpy(reply->interfaces[count].spec.iface_id, port->vm.machineid, sizeof(port->vm.machineid)); + rte_memcpy(reply->interfaces[count].spec.iface_id, port->iface.id, sizeof(port->iface.id)); } count++; } diff --git a/src/meson.build b/src/meson.build index d5c27b63d..7d05a4221 100644 --- a/src/meson.build +++ b/src/meson.build @@ -36,12 +36,15 @@ dp_sources = [ 'rte_flow/dp_rte_flow_traffic_forward.c', 'rte_flow/dp_rte_flow_capture.c', 'dp_argparse.c', + 'dp_cntrack.c', 'dp_conf.c', 'dp_error.c', 'dp_firewall.c', 'dp_flow.c', 'dp_graph.c', 'dp_hairpin.c', + 'dp_iface.c', + 'dp_internal_stats.c', 'dp_lb.c', 'dp_log.c', 'dp_lpm.c', @@ -55,12 +58,9 @@ dp_sources = [ 'dp_telemetry.c', 'dp_timers.c', 'dp_util.c', - 'dp_vm.c', 'dp_vnf.c', 'dp_vni.c', 'dpdk_layer.c', - 'dp_internal_stats.c', - 'dp_cntrack.c' ] if get_option('enable_virtual_services') dp_sources += [ diff --git a/src/nodes/arp_node.c b/src/nodes/arp_node.c index 87ebec10a..f990449de 100644 --- a/src/nodes/arp_node.c +++ b/src/nodes/arp_node.c @@ -7,7 +7,7 @@ #include "dp_error.h" #include "dp_log.h" #include "dp_lpm.h" -#include "dp_vm.h" +#include "dp_iface.h" #include "nodes/common_node.h" DP_NODE_REGISTER(ARP, arp, DP_NODE_DEFAULT_NEXT_ONLY); @@ -35,12 +35,12 @@ static __rte_always_inline bool arp_handled(struct rte_mbuf *m) rte_be32_t requested_ip = incoming_arp_hdr->arp_data.arp_tip; rte_be32_t sender_ip = incoming_arp_hdr->arp_data.arp_sip; struct rte_ether_addr tmp_addr; - struct dp_port *port = dp_get_port(m); + struct dp_port *port = dp_get_in_port(m); uint32_t temp_ip; // ARP reply from VM - if (dp_arp_cycle_needed(port) && sender_ip == htonl(port->vm.info.own_ip)) { - rte_ether_addr_copy(&incoming_eth_hdr->src_addr, &port->vm.info.neigh_mac); + if (dp_arp_cycle_needed(port) && sender_ip == htonl(port->iface.cfg.own_ip)) { + rte_ether_addr_copy(&incoming_eth_hdr->src_addr, &port->neigh_mac); return true; } @@ -50,9 +50,9 @@ static __rte_always_inline bool arp_handled(struct rte_mbuf *m) // respond back to origin address from this address (reuse the packet) rte_ether_addr_copy(&incoming_arp_hdr->arp_data.arp_sha, &incoming_eth_hdr->dst_addr); - rte_ether_addr_copy(&port->vm.info.own_mac, &incoming_eth_hdr->src_addr); + rte_ether_addr_copy(&port->own_mac, &incoming_eth_hdr->src_addr); rte_ether_addr_copy(&incoming_arp_hdr->arp_data.arp_sha, &tmp_addr); - rte_ether_addr_copy(&port->vm.info.own_mac, &incoming_arp_hdr->arp_data.arp_sha); + rte_ether_addr_copy(&port->own_mac, &incoming_arp_hdr->arp_data.arp_sha); rte_ether_addr_copy(&tmp_addr, &incoming_arp_hdr->arp_data.arp_tha); temp_ip = incoming_arp_hdr->arp_data.arp_sip; incoming_arp_hdr->arp_data.arp_sip = incoming_arp_hdr->arp_data.arp_tip; diff --git a/src/nodes/conntrack_node.c b/src/nodes/conntrack_node.c index 15ab00191..1eea3c166 100644 --- a/src/nodes/conntrack_node.c +++ b/src/nodes/conntrack_node.c @@ -52,7 +52,7 @@ static __rte_always_inline rte_edge_t get_next_index(__rte_unused struct rte_nod return CONNTRACK_NEXT_DROP; } - if (!dp_get_port(m)->is_pf) + if (!dp_get_in_port(m)->is_pf) return CONNTRACK_NEXT_DNAT; switch (df->vnf_type) { diff --git a/src/nodes/dhcp_node.c b/src/nodes/dhcp_node.c index 303ed8c5e..dcef0ad2e 100644 --- a/src/nodes/dhcp_node.c +++ b/src/nodes/dhcp_node.c @@ -11,7 +11,7 @@ #include "dp_error.h" #include "dp_log.h" #include "dp_lpm.h" -#include "dp_vm.h" +#include "dp_iface.h" #include "nodes/common_node.h" DP_NODE_REGISTER(DHCP, dhcp, DP_NODE_DEFAULT_NEXT_ONLY); @@ -168,7 +168,7 @@ static __rte_always_inline rte_edge_t get_next_index(struct rte_node *node, stru struct rte_ipv4_hdr *incoming_ipv4_hdr; struct rte_udp_hdr *incoming_udp_hdr; struct dp_dhcp_header *dhcp_hdr; - struct dp_port *port = dp_get_port(m); + struct dp_port *port = dp_get_in_port(m); int options_len, header_size; uint8_t msg_type; @@ -215,9 +215,9 @@ static __rte_always_inline rte_edge_t get_next_index(struct rte_node *node, stru m->l4_len = sizeof(struct rte_udp_hdr); rte_ether_addr_copy(&incoming_eth_hdr->src_addr, &incoming_eth_hdr->dst_addr); - rte_ether_addr_copy(&port->vm.info.own_mac, &incoming_eth_hdr->src_addr); + rte_ether_addr_copy(&port->own_mac, &incoming_eth_hdr->src_addr); if (response_type == DHCPACK) - rte_ether_addr_copy(&incoming_eth_hdr->dst_addr, &port->vm.info.neigh_mac); + rte_ether_addr_copy(&incoming_eth_hdr->dst_addr, &port->neigh_mac); incoming_ipv4_hdr->src_addr = server_ip; @@ -226,14 +226,14 @@ static __rte_always_inline rte_edge_t get_next_index(struct rte_node *node, stru dhcp_hdr->op = DP_BOOTP_REPLY; dhcp_hdr->magic = dhcp_hdr_magic; - dhcp_hdr->yiaddr = htonl(port->vm.info.own_ip); + dhcp_hdr->yiaddr = htonl(port->iface.cfg.own_ip); dhcp_hdr->giaddr = server_ip; rte_memcpy(dhcp_hdr->chaddr, incoming_eth_hdr->dst_addr.addr_bytes, 6); if (pxe_mode != DP_PXE_MODE_NONE) { memset(&incoming_eth_hdr->dst_addr, ~0, sizeof(incoming_eth_hdr->dst_addr)); incoming_ipv4_hdr->dst_addr = 0xFFFFFFFF; - pxe_srv_ip = htonl(port->vm.info.pxe_ip); + pxe_srv_ip = htonl(port->iface.cfg.pxe_ip); dhcp_hdr->siaddr = pxe_srv_ip; switch (pxe_mode) { case DP_PXE_MODE_TFTP: @@ -246,13 +246,13 @@ static __rte_always_inline rte_edge_t get_next_index(struct rte_node *node, stru return DHCP_NEXT_DROP; } snprintf(dhcp_hdr->file, sizeof(dhcp_hdr->file), "%s%s%s", - "http://", pxe_srv_ip_str, port->vm.info.pxe_str); + "http://", pxe_srv_ip_str, port->iface.cfg.pxe_str); break; case DP_PXE_MODE_NONE: assert(false); } } else { - incoming_ipv4_hdr->dst_addr = htonl(port->vm.info.own_ip); + incoming_ipv4_hdr->dst_addr = htonl(port->iface.cfg.own_ip); dhcp_hdr->siaddr = server_ip; } diff --git a/src/nodes/dhcpv6_node.c b/src/nodes/dhcpv6_node.c index 8d9ea1715..5395825be 100644 --- a/src/nodes/dhcpv6_node.c +++ b/src/nodes/dhcpv6_node.c @@ -108,7 +108,7 @@ static __rte_always_inline int parse_options(struct rte_mbuf *m, } reply_options->opt_iana = opt_iana_template; reply_options->opt_iana.ia_na.iaid = ((const struct dhcpv6_ia_na *)&opt->data)->iaid; - rte_memcpy(reply_options->opt_iana.ia_na.options[0].addr.ipv6, dp_get_port(m)->vm.info.dhcp_ipv6, 16); + rte_memcpy(reply_options->opt_iana.ia_na.options[0].addr.ipv6, dp_get_in_port(m)->iface.cfg.dhcp_ipv6, 16); reply_options->opt_iana_len = sizeof(opt_iana_template); break; case DHCPV6_OPT_RAPID_COMMIT: @@ -209,7 +209,7 @@ static __rte_always_inline rte_edge_t get_next_index(struct rte_node *node, stru // switch the packet's direction rte_ether_addr_copy(&req_eth_hdr->src_addr, &req_eth_hdr->dst_addr); - rte_ether_addr_copy(&dp_get_port(m)->vm.info.own_mac, &req_eth_hdr->src_addr); + rte_ether_addr_copy(&dp_get_in_port(m)->own_mac, &req_eth_hdr->src_addr); rte_memcpy(req_ipv6_hdr->dst_addr, req_ipv6_hdr->src_addr, sizeof(req_ipv6_hdr->dst_addr)); rte_memcpy(req_ipv6_hdr->src_addr, own_ip6, sizeof(req_ipv6_hdr->src_addr)); diff --git a/src/nodes/dnat_node.c b/src/nodes/dnat_node.c index 1d577df8d..a201f75b0 100644 --- a/src/nodes/dnat_node.c +++ b/src/nodes/dnat_node.c @@ -32,7 +32,7 @@ static __rte_always_inline rte_edge_t get_next_index(__rte_unused struct rte_nod dst_ip = ntohl(df->dst.dst_addr); vni = df->tun_info.dst_vni; if (vni == 0) - vni = dp_get_port(m)->vm.vni; + vni = dp_get_in_port(m)->iface.vni; dnat_data = dp_get_dnat_data(dst_ip, vni); if (dnat_data) { diff --git a/src/nodes/firewall_node.c b/src/nodes/firewall_node.c index 5cfb6114a..5e48ffcbf 100644 --- a/src/nodes/firewall_node.c +++ b/src/nodes/firewall_node.c @@ -23,8 +23,8 @@ static __rte_always_inline rte_edge_t get_next_index(__rte_unused struct rte_nod { struct dp_flow *df = dp_get_flow_ptr(m); struct flow_value *cntrack = df->conntrack; - const struct dp_port *src_port = dp_get_port(m); - const struct dp_port *dst_port = dp_get_dst_port(df); + const struct dp_port *in_port = dp_get_in_port(m); + const struct dp_port *out_port = dp_get_out_port(df); enum dp_fwall_action action; // currently only IPv4 firewall is implemented @@ -32,7 +32,7 @@ static __rte_always_inline rte_edge_t get_next_index(__rte_unused struct rte_nod if (DP_IS_FLOW_STATUS_FLAG_FIREWALL(cntrack->flow_status)) { action = (enum dp_fwall_action)cntrack->fwall_action[df->flags.dir]; } else if (df->flags.dir == DP_FLOW_DIR_ORG) { - action = dp_get_firewall_action(df, src_port, dst_port); + action = dp_get_firewall_action(df, in_port, out_port); cntrack->fwall_action[DP_FLOW_DIR_ORG] = (uint8_t)action; cntrack->fwall_action[DP_FLOW_DIR_REPLY] = (uint8_t)action; cntrack->flow_status |= DP_FLOW_STATUS_FLAG_FIREWALL; @@ -43,10 +43,10 @@ static __rte_always_inline rte_edge_t get_next_index(__rte_unused struct rte_nod // return FIREWALL_NEXT_DROP; } - if (dst_port->is_pf) + if (out_port->is_pf) return FIREWALL_NEXT_IPIP_ENCAP; - return next_tx_index[dst_port->port_id]; + return next_tx_index[out_port->port_id]; } static uint16_t firewall_node_process(struct rte_graph *graph, diff --git a/src/nodes/ipip_encap_node.c b/src/nodes/ipip_encap_node.c index 99422b3e7..b51fbfa28 100644 --- a/src/nodes/ipip_encap_node.c +++ b/src/nodes/ipip_encap_node.c @@ -52,7 +52,7 @@ static __rte_always_inline rte_edge_t get_next_index(struct rte_node *node, stru return IPIP_ENCAP_NEXT_DROP; } - dp_fill_ether_hdr(ether_hdr, dp_get_dst_port(df), RTE_ETHER_TYPE_IPV6); + dp_fill_ether_hdr(ether_hdr, dp_get_out_port(df), RTE_ETHER_TYPE_IPV6); ipv6_hdr = (struct rte_ipv6_hdr *)(ether_hdr + 1); ipv6_hdr->hop_limits = DP_IP6_HOP_LIMIT; @@ -63,7 +63,7 @@ static __rte_always_inline rte_edge_t get_next_index(struct rte_node *node, stru // store the original ipv6 dst address in the packet rte_memcpy(ipv6_hdr->src_addr, df->tun_info.ul_src_addr6, sizeof(ipv6_hdr->src_addr)); else - rte_memcpy(ipv6_hdr->src_addr, dp_get_port_ul_ip6(dp_get_port(m)), sizeof(ipv6_hdr->src_addr)); + rte_memcpy(ipv6_hdr->src_addr, dp_get_port_ul_ipv6(dp_get_in_port(m)), sizeof(ipv6_hdr->src_addr)); rte_memcpy(ipv6_hdr->dst_addr, df->tun_info.ul_dst_addr6, sizeof(ipv6_hdr->dst_addr)); ipv6_hdr->proto = df->tun_info.proto_id; diff --git a/src/nodes/ipv4_lookup_node.c b/src/nodes/ipv4_lookup_node.c index 7720276f2..13931f3e7 100644 --- a/src/nodes/ipv4_lookup_node.c +++ b/src/nodes/ipv4_lookup_node.c @@ -22,35 +22,35 @@ DP_NODE_REGISTER_NOINIT(IPV4_LOOKUP, ipv4_lookup, NEXT_NODES); static __rte_always_inline rte_edge_t get_next_index(__rte_unused struct rte_node *node, struct rte_mbuf *m) { struct dp_flow *df = dp_get_flow_ptr(m); - struct vm_route route; + struct dp_iface_route route; uint32_t route_key = 0; - const struct dp_port *src_port = dp_get_port(m); - const struct dp_port *dst_port; + const struct dp_port *in_port = dp_get_in_port(m); + const struct dp_port *out_port; // TODO: add broadcast routes when machine is added if (df->l4_type == DP_IP_PROTO_UDP && df->l4_info.trans_port.dst_port == htons(DP_BOOTP_SRV_PORT)) return IPV4_LOOKUP_NEXT_DHCP; - dst_port = dp_get_ip4_dst_port(src_port, df->tun_info.dst_vni, df, &route, &route_key); - if (!dst_port) + out_port = dp_get_ip4_out_port(in_port, df->tun_info.dst_vni, df, &route, &route_key); + if (!out_port) return IPV4_LOOKUP_NEXT_DROP; - if (dst_port->is_pf) { - if (src_port->is_pf) + if (out_port->is_pf) { + if (in_port->is_pf) return IPV4_LOOKUP_NEXT_DROP; rte_memcpy(df->tun_info.ul_dst_addr6, route.nh_ipv6, sizeof(df->tun_info.ul_dst_addr6)); - dst_port = dp_multipath_get_pf(df->dp_flow_hash); + out_port = dp_multipath_get_pf(df->dp_flow_hash); } else { // next hop is known, fill in Ether header // (PF egress goes through a tunnel that destroys Ether header) - dp_fill_ether_hdr(rte_pktmbuf_mtod(m, struct rte_ether_hdr *), dst_port, RTE_ETHER_TYPE_IPV4); + dp_fill_ether_hdr(rte_pktmbuf_mtod(m, struct rte_ether_hdr *), out_port, RTE_ETHER_TYPE_IPV4); } - if (!src_port->is_pf) + if (!in_port->is_pf) df->tun_info.dst_vni = route.vni; df->flags.public_flow = route_key == 0 ? DP_FLOW_SOUTH_NORTH : DP_FLOW_WEST_EAST; - df->nxt_hop = dst_port->port_id; // always valid since coming from struct dp_port + df->nxt_hop = out_port->port_id; // always valid since coming from struct dp_port return IPV4_LOOKUP_NEXT_NAT; } diff --git a/src/nodes/ipv6_lookup_node.c b/src/nodes/ipv6_lookup_node.c index c3c8810d8..872f51c9c 100644 --- a/src/nodes/ipv6_lookup_node.c +++ b/src/nodes/ipv6_lookup_node.c @@ -6,7 +6,7 @@ #include "dp_conf.h" #include "dp_error.h" #include "dp_mbuf_dyn.h" -#include "dp_vm.h" +#include "dp_iface.h" #include "nodes/common_node.h" #include "protocols/dp_dhcpv6.h" #include "rte_flow/dp_rte_flow.h" @@ -21,9 +21,9 @@ static __rte_always_inline rte_edge_t get_next_index(__rte_unused struct rte_nod struct dp_flow *df = dp_get_flow_ptr(m); struct rte_ether_hdr *ether_hdr = rte_pktmbuf_mtod(m, struct rte_ether_hdr *); struct rte_ipv6_hdr *ipv6_hdr = (struct rte_ipv6_hdr *)(ether_hdr + 1); - struct vm_route route; - const struct dp_port *src_port = dp_get_port(m); - const struct dp_port *dst_port; + struct dp_iface_route route; + const struct dp_port *in_port = dp_get_in_port(m); + const struct dp_port *out_port; int t_vni; dp_extract_ipv6_header(df, ipv6_hdr); @@ -35,29 +35,29 @@ static __rte_always_inline rte_edge_t get_next_index(__rte_unused struct rte_nod if (df->l4_type == DP_IP_PROTO_UDP && df->l4_info.trans_port.dst_port == htons(DHCPV6_SERVER_PORT)) return IPV6_LOOKUP_NEXT_DHCPV6; - t_vni = src_port->is_pf ? df->tun_info.dst_vni : 0; + t_vni = in_port->is_pf ? df->tun_info.dst_vni : 0; - dst_port = dp_get_ip6_dst_port(src_port, t_vni, ipv6_hdr, &route); - if (!dst_port) + out_port = dp_get_ip6_out_port(in_port, t_vni, ipv6_hdr, &route); + if (!out_port) return IPV6_LOOKUP_NEXT_DROP; - if (dst_port->is_pf) { - if (src_port->is_pf) + if (out_port->is_pf) { + if (in_port->is_pf) return IPV6_LOOKUP_NEXT_DROP; rte_memcpy(df->tun_info.ul_dst_addr6, route.nh_ipv6, sizeof(df->tun_info.ul_dst_addr6)); } else { // next hop is known, fill in Ether header // (PF egress goes through a tunnel that destroys Ether header) - dp_fill_ether_hdr(ether_hdr, dst_port, RTE_ETHER_TYPE_IPV6); + dp_fill_ether_hdr(ether_hdr, out_port, RTE_ETHER_TYPE_IPV6); } if (dp_conf_is_offload_enabled()) df->flags.offload_ipv6 = 1; - if (!src_port->is_pf) + if (!in_port->is_pf) df->tun_info.dst_vni = route.vni; - df->nxt_hop = dst_port->port_id; // always valid since coming from struct dp_port + df->nxt_hop = out_port->port_id; // always valid since coming from struct dp_port return IPV6_LOOKUP_NEXT_FIREWALL; } diff --git a/src/nodes/ipv6_nd_node.c b/src/nodes/ipv6_nd_node.c index 6607f801d..9389d8103 100644 --- a/src/nodes/ipv6_nd_node.c +++ b/src/nodes/ipv6_nd_node.c @@ -29,10 +29,10 @@ static __rte_always_inline rte_edge_t get_next_index(__rte_unused struct rte_nod const uint8_t *rt_ip = dp_get_gw_ip6(); struct nd_msg *nd_msg; struct ra_msg *req_ra_msg; - struct dp_port *port = dp_get_port(m); + struct dp_port *port = dp_get_in_port(m); rte_ether_addr_copy(&req_eth_hdr->src_addr, &req_eth_hdr->dst_addr); - rte_ether_addr_copy(&port->vm.info.own_mac, &req_eth_hdr->src_addr); + rte_ether_addr_copy(&port->own_mac, &req_eth_hdr->src_addr); if (!memcmp(req_ipv6_hdr->src_addr, dp_unspecified_ipv6, sizeof(req_ipv6_hdr->src_addr))) rte_memcpy(req_ipv6_hdr->dst_addr, dp_multicast_ipv6, sizeof(req_ipv6_hdr->dst_addr)); @@ -48,8 +48,8 @@ static __rte_always_inline rte_edge_t get_next_index(__rte_unused struct rte_nod nd_msg = (struct nd_msg *)(req_ipv6_hdr + 1); if (memcmp(&nd_msg->target, rt_ip, sizeof(nd_msg->target))) return IPV6_ND_NEXT_DROP; - rte_ether_addr_copy(&req_eth_hdr->dst_addr, &port->vm.info.neigh_mac); - rte_memcpy(port->vm.info.vm_ipv6, req_ipv6_hdr->dst_addr, sizeof(port->vm.info.vm_ipv6)); + rte_ether_addr_copy(&req_eth_hdr->dst_addr, &port->neigh_mac); + rte_memcpy(port->iface.cfg.own_ipv6, req_ipv6_hdr->dst_addr, sizeof(port->iface.cfg.own_ipv6)); req_icmp6_hdr->icmp6_type = NDISC_NEIGHBOUR_ADVERTISEMENT; req_icmp6_hdr->icmp6_solicited = 1; req_icmp6_hdr->icmp6_override = 1; diff --git a/src/nodes/lb_node.c b/src/nodes/lb_node.c index e562f23af..649fceb1d 100644 --- a/src/nodes/lb_node.c +++ b/src/nodes/lb_node.c @@ -40,7 +40,7 @@ static __rte_always_inline rte_edge_t get_next_index(__rte_unused struct rte_nod dst_ip = ntohl(df->dst.dst_addr); vni = df->tun_info.dst_vni; if (vni == 0) - vni = dp_get_port(m)->vm.vni; + vni = dp_get_in_port(m)->iface.vni; if (DP_IS_FLOW_STATUS_FLAG_NONE(cntrack->flow_status) && df->flags.dir == DP_FLOW_DIR_ORG diff --git a/src/nodes/snat_node.c b/src/nodes/snat_node.c index 686c53b69..41e537238 100644 --- a/src/nodes/snat_node.c +++ b/src/nodes/snat_node.c @@ -31,12 +31,12 @@ static __rte_always_inline rte_edge_t get_next_index(__rte_unused struct rte_nod return SNAT_NEXT_FIREWALL; if (DP_IS_FLOW_STATUS_FLAG_NONE(cntrack->flow_status) && df->flags.dir == DP_FLOW_DIR_ORG) { - port = dp_get_port(m); + port = dp_get_in_port(m); src_ip = ntohl(df->src.src_addr); - vni = port->vm.vni; - snat_data = dp_get_vm_snat_data(src_ip, vni); + vni = port->iface.vni; + snat_data = dp_get_iface_snat_data(src_ip, vni); - if (snat_data && (snat_data->vip_ip != 0 || snat_data->network_nat_ip != 0) + if (snat_data && (snat_data->vip_ip != 0 || snat_data->nat_ip != 0) && df->flags.public_flow == DP_FLOW_SOUTH_NORTH) { ipv4_hdr = dp_get_ipv4_hdr(m); // TODO(tao?): in case of both VIP and NAT set, VIP gets written here and immediately overwritten by NAT @@ -44,12 +44,12 @@ static __rte_always_inline rte_edge_t get_next_index(__rte_unused struct rte_nod ipv4_hdr->src_addr = htonl(snat_data->vip_ip); cntrack->nf_info.nat_type = DP_FLOW_NAT_TYPE_VIP; } - if (snat_data->network_nat_ip != 0) { + if (snat_data->nat_ip != 0) { ret = dp_allocate_network_snat_port(snat_data, df, vni); if (DP_FAILED(ret)) return SNAT_NEXT_DROP; nat_port = (uint16_t)ret; - ipv4_hdr->src_addr = htonl(snat_data->network_nat_ip); + ipv4_hdr->src_addr = htonl(snat_data->nat_ip); DP_STATS_NAT_INC_USED_PORT_CNT(port); @@ -76,7 +76,7 @@ static __rte_always_inline rte_edge_t get_next_index(__rte_unused struct rte_nod cntrack->flow_status |= DP_FLOW_STATUS_FLAG_SRC_NAT; dp_delete_flow(&cntrack->flow_key[DP_FLOW_DIR_REPLY]); cntrack->flow_key[DP_FLOW_DIR_REPLY].ip_dst = ntohl(ipv4_hdr->src_addr); - if (snat_data->network_nat_ip != 0) + if (snat_data->nat_ip != 0) cntrack->flow_key[DP_FLOW_DIR_REPLY].port_dst = df->nat_port; if (DP_FAILED(dp_add_flow(&cntrack->flow_key[DP_FLOW_DIR_REPLY], cntrack))) diff --git a/src/nodes/virtsvc_node.c b/src/nodes/virtsvc_node.c index 205910cf7..bd62a81c1 100644 --- a/src/nodes/virtsvc_node.c +++ b/src/nodes/virtsvc_node.c @@ -9,7 +9,7 @@ #include "dp_error.h" #include "dp_log.h" #include "dp_mbuf_dyn.h" -#include "dp_vm.h" +#include "dp_iface.h" #include "nodes/common_node.h" #include "rte_flow/dp_rte_flow.h" @@ -247,7 +247,7 @@ static __rte_always_inline rte_edge_t get_next_index(struct rte_node *node, stru if (dp_conf_is_offload_enabled()) DPNODE_LOG_WARNING(node, "Virtual services not supported while offloading"); - if (dp_get_port(m)->is_pf) + if (dp_get_in_port(m)->is_pf) return virtsvc_reply_next(node, m, df); else return virtsvc_request_next(node, m, df); diff --git a/src/rte_flow/dp_rte_flow_capture.c b/src/rte_flow/dp_rte_flow_capture.c index da4fc8102..4215d3858 100644 --- a/src/rte_flow/dp_rte_flow_capture.c +++ b/src/rte_flow/dp_rte_flow_capture.c @@ -75,8 +75,8 @@ void dp_configure_pkt_capture_action(uint8_t *encaped_mirror_hdr, const struct dp_port *outgoing_port = dp_get_pf0(); const struct dp_capture_hdr_config *capture_hdr_config = dp_get_capture_hdr_config(); - rte_ether_addr_copy(&outgoing_port->vm.info.neigh_mac, &encap_eth_hdr->dst_addr); - rte_ether_addr_copy(&outgoing_port->vm.info.own_mac, &encap_eth_hdr->src_addr); + rte_ether_addr_copy(&outgoing_port->neigh_mac, &encap_eth_hdr->dst_addr); + rte_ether_addr_copy(&outgoing_port->own_mac, &encap_eth_hdr->src_addr); encap_eth_hdr->ether_type = htons(RTE_ETHER_TYPE_IPV6); rte_memcpy(new_ipv6_hdr->src_addr, dp_conf_get_underlay_ip(), sizeof(new_ipv6_hdr->src_addr)); diff --git a/src/rte_flow/dp_rte_flow_traffic_forward.c b/src/rte_flow/dp_rte_flow_traffic_forward.c index 2eaa95371..cf79be325 100644 --- a/src/rte_flow/dp_rte_flow_traffic_forward.c +++ b/src/rte_flow/dp_rte_flow_traffic_forward.c @@ -166,15 +166,15 @@ static __rte_always_inline void dp_create_ipip_encap_header(uint8_t raw_hdr[DP_I struct rte_ether_hdr *encap_eth_hdr = (struct rte_ether_hdr *)raw_hdr; struct rte_ipv6_hdr *encap_ipv6_hdr = (struct rte_ipv6_hdr *)(&raw_hdr[sizeof(struct rte_ether_hdr)]); - rte_ether_addr_copy(&outgoing_port->vm.info.neigh_mac, &encap_eth_hdr->dst_addr); - rte_ether_addr_copy(&outgoing_port->vm.info.own_mac, &encap_eth_hdr->src_addr); + rte_ether_addr_copy(&outgoing_port->neigh_mac, &encap_eth_hdr->dst_addr); + rte_ether_addr_copy(&outgoing_port->own_mac, &encap_eth_hdr->src_addr); encap_eth_hdr->ether_type = htons(RTE_ETHER_TYPE_IPV6); encap_ipv6_hdr->vtc_flow = htonl(DP_IP6_VTC_FLOW); encap_ipv6_hdr->payload_len = 0; encap_ipv6_hdr->proto = df->tun_info.proto_id; encap_ipv6_hdr->hop_limits = DP_IP6_HOP_LIMIT; - rte_memcpy(encap_ipv6_hdr->src_addr, dp_get_port_ul_ip6(incoming_port), sizeof(encap_ipv6_hdr->src_addr)); + rte_memcpy(encap_ipv6_hdr->src_addr, dp_get_port_ul_ipv6(incoming_port), sizeof(encap_ipv6_hdr->src_addr)); rte_memcpy(encap_ipv6_hdr->dst_addr, df->tun_info.ul_dst_addr6, sizeof(encap_ipv6_hdr->dst_addr)); } @@ -379,8 +379,8 @@ int dp_offload_handle_tunnel_decap_traffic(struct dp_flow *df, df->conntrack->incoming_flow_offloaded_flag.pf0 = true; // prepare the new ethernet header to replace the IPIP one - rte_ether_addr_copy(&outgoing_port->vm.info.neigh_mac, &new_eth_hdr.dst_addr); - rte_ether_addr_copy(&outgoing_port->vm.info.own_mac, &new_eth_hdr.src_addr); + rte_ether_addr_copy(&outgoing_port->neigh_mac, &new_eth_hdr.dst_addr); + rte_ether_addr_copy(&outgoing_port->own_mac, &new_eth_hdr.src_addr); new_eth_hdr.ether_type = htons(df->l3_type); // restore the actual incoming pkt's ipv6 dst addr @@ -544,8 +544,8 @@ int dp_offload_handle_local_traffic(struct dp_flow *df, dp_set_end_flow_item(&pattern[pattern_cnt++]); // set proper ethernet addresses - dp_set_dst_mac_set_action(&actions[action_cnt++], &set_dst_mac, &outgoing_port->vm.info.neigh_mac); - dp_set_src_mac_set_action(&actions[action_cnt++], &set_src_mac, &outgoing_port->vm.info.own_mac); + dp_set_dst_mac_set_action(&actions[action_cnt++], &set_dst_mac, &outgoing_port->neigh_mac); + dp_set_src_mac_set_action(&actions[action_cnt++], &set_src_mac, &outgoing_port->own_mac); // replace IPv4 address in overlay if VIP/NAT enabled if (df->flags.nat == DP_NAT_CHG_DST_IP) { @@ -631,8 +631,8 @@ int dp_offload_handle_in_network_traffic(struct dp_flow *df, // in network traffic has to be set via the other pf port via hairpin outgoing_port = incoming_port == dp_get_pf0() ? dp_get_pf1() : dp_get_pf0(); // do *not* change df->nxt_hop though, as that carries the "proper" outgoing port - dp_set_src_mac_set_action(&actions[action_cnt++], &set_src_mac, &outgoing_port->vm.info.own_mac); - dp_set_dst_mac_set_action(&actions[action_cnt++], &set_dst_mac, &outgoing_port->vm.info.neigh_mac); + dp_set_src_mac_set_action(&actions[action_cnt++], &set_src_mac, &outgoing_port->own_mac); + dp_set_dst_mac_set_action(&actions[action_cnt++], &set_dst_mac, &outgoing_port->neigh_mac); // set the right underlay address dp_set_ipv6_set_dst_action(&actions[action_cnt++], &set_ipv6, df->tun_info.ul_dst_addr6); @@ -671,42 +671,42 @@ int dp_offload_handle_in_network_traffic(struct dp_flow *df, int dp_offload_handler(struct rte_mbuf *m, struct dp_flow *df) { - const struct dp_port *incoming_port = dp_get_port(m); - const struct dp_port *outgoing_port = dp_get_dst_port(df); + const struct dp_port *in_port = dp_get_in_port(m); + const struct dp_port *out_port = dp_get_out_port(df); int ret; - if (!incoming_port->is_pf && !outgoing_port->is_pf) { + if (!in_port->is_pf && !out_port->is_pf) { // VF -> VF - ret = dp_offload_handle_local_traffic(df, incoming_port, outgoing_port); + ret = dp_offload_handle_local_traffic(df, in_port, out_port); if (DP_FAILED(ret)) - DPS_LOG_ERR("Failed to install local flow rule", DP_LOG_PORT(incoming_port), DP_LOG_PORT(outgoing_port), DP_LOG_RET(ret)); - } else if (outgoing_port->is_pf) { + DPS_LOG_ERR("Failed to install local flow rule", DP_LOG_PORT(in_port), DP_LOG_PORT(out_port), DP_LOG_RET(ret)); + } else if (out_port->is_pf) { if (df->conntrack->nf_info.nat_type == DP_FLOW_NAT_TYPE_NETWORK_NEIGH || df->conntrack->nf_info.nat_type == DP_FLOW_LB_TYPE_FORWARD ) { - if (unlikely(!incoming_port->is_pf)) { - DPS_LOG_ERR("Invalid in-network flow", DP_LOG_PORT(incoming_port), DP_LOG_PORT(outgoing_port)); + if (unlikely(!in_port->is_pf)) { + DPS_LOG_ERR("Invalid in-network flow", DP_LOG_PORT(in_port), DP_LOG_PORT(out_port)); return DP_ERROR; } // PF -> PF - ret = dp_offload_handle_in_network_traffic(df, incoming_port); + ret = dp_offload_handle_in_network_traffic(df, in_port); if (DP_FAILED(ret)) - DPS_LOG_ERR("Failed to install in-network flow rule", DP_LOG_PORT(incoming_port), DP_LOG_PORT(outgoing_port), DP_LOG_RET(ret)); + DPS_LOG_ERR("Failed to install in-network flow rule", DP_LOG_PORT(in_port), DP_LOG_PORT(out_port), DP_LOG_RET(ret)); } else { - if (unlikely(incoming_port->is_pf)) { - DPS_LOG_ERR("Invalid encap flow", DP_LOG_PORT(incoming_port), DP_LOG_PORT(outgoing_port)); + if (unlikely(in_port->is_pf)) { + DPS_LOG_ERR("Invalid encap flow", DP_LOG_PORT(in_port), DP_LOG_PORT(out_port)); return DP_ERROR; } // VF -> PF - ret = dp_offload_handle_tunnel_encap_traffic(df, incoming_port, outgoing_port); + ret = dp_offload_handle_tunnel_encap_traffic(df, in_port, out_port); if (DP_FAILED(ret)) - DPS_LOG_ERR("Failed to install encap flow rule", DP_LOG_PORT(incoming_port), DP_LOG_PORT(outgoing_port), DP_LOG_RET(ret)); + DPS_LOG_ERR("Failed to install encap flow rule", DP_LOG_PORT(in_port), DP_LOG_PORT(out_port), DP_LOG_RET(ret)); } } else { // PF -> VF - ret = dp_offload_handle_tunnel_decap_traffic(df, incoming_port, outgoing_port, dp_get_pkt_mark(m)->flags.is_recirc); + ret = dp_offload_handle_tunnel_decap_traffic(df, in_port, out_port, dp_get_pkt_mark(m)->flags.is_recirc); if (DP_FAILED(ret)) - DPS_LOG_ERR("Failed to install decap flow rule", DP_LOG_PORT(incoming_port), DP_LOG_PORT(outgoing_port), DP_LOG_RET(ret)); + DPS_LOG_ERR("Failed to install decap flow rule", DP_LOG_PORT(in_port), DP_LOG_PORT(out_port), DP_LOG_RET(ret)); } return ret;