| /* |
| * QEMU rocker switch emulation - OF-DPA flow processing support |
| * |
| * Copyright (c) 2014 Scott Feldman <sfeldma@gmail.com> |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published by |
| * the Free Software Foundation; either version 2 of the License, or |
| * (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| * GNU General Public License for more details. |
| */ |
| |
| #include "qemu/osdep.h" |
| #include "net/eth.h" |
| #include "qemu/iov.h" |
| #include "qemu/timer.h" |
| #include "qmp-commands.h" |
| |
| #include "rocker.h" |
| #include "rocker_hw.h" |
| #include "rocker_fp.h" |
| #include "rocker_tlv.h" |
| #include "rocker_world.h" |
| #include "rocker_desc.h" |
| #include "rocker_of_dpa.h" |
| |
| static const MACAddr zero_mac = { .a = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } }; |
| static const MACAddr ff_mac = { .a = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff } }; |
| |
| typedef struct of_dpa { |
| World *world; |
| GHashTable *flow_tbl; |
| GHashTable *group_tbl; |
| unsigned int flow_tbl_max_size; |
| unsigned int group_tbl_max_size; |
| } OfDpa; |
| |
| /* flow_key stolen mostly from OVS |
| * |
| * Note: fields that compare with network packet header fields |
| * are stored in network order (BE) to avoid per-packet field |
| * byte-swaps. |
| */ |
| |
| typedef struct of_dpa_flow_key { |
| uint32_t in_pport; /* ingress port */ |
| uint32_t tunnel_id; /* overlay tunnel id */ |
| uint32_t tbl_id; /* table id */ |
| struct { |
| __be16 vlan_id; /* 0 if no VLAN */ |
| MACAddr src; /* ethernet source address */ |
| MACAddr dst; /* ethernet destination address */ |
| __be16 type; /* ethernet frame type */ |
| } eth; |
| struct { |
| uint8_t proto; /* IP protocol or ARP opcode */ |
| uint8_t tos; /* IP ToS */ |
| uint8_t ttl; /* IP TTL/hop limit */ |
| uint8_t frag; /* one of FRAG_TYPE_* */ |
| } ip; |
| union { |
| struct { |
| struct { |
| __be32 src; /* IP source address */ |
| __be32 dst; /* IP destination address */ |
| } addr; |
| union { |
| struct { |
| __be16 src; /* TCP/UDP/SCTP source port */ |
| __be16 dst; /* TCP/UDP/SCTP destination port */ |
| __be16 flags; /* TCP flags */ |
| } tp; |
| struct { |
| MACAddr sha; /* ARP source hardware address */ |
| MACAddr tha; /* ARP target hardware address */ |
| } arp; |
| }; |
| } ipv4; |
| struct { |
| struct { |
| Ipv6Addr src; /* IPv6 source address */ |
| Ipv6Addr dst; /* IPv6 destination address */ |
| } addr; |
| __be32 label; /* IPv6 flow label */ |
| struct { |
| __be16 src; /* TCP/UDP/SCTP source port */ |
| __be16 dst; /* TCP/UDP/SCTP destination port */ |
| __be16 flags; /* TCP flags */ |
| } tp; |
| struct { |
| Ipv6Addr target; /* ND target address */ |
| MACAddr sll; /* ND source link layer address */ |
| MACAddr tll; /* ND target link layer address */ |
| } nd; |
| } ipv6; |
| }; |
| int width; /* how many uint64_t's in key? */ |
| } OfDpaFlowKey; |
| |
| /* Width of key which includes field 'f' in u64s, rounded up */ |
| #define FLOW_KEY_WIDTH(f) \ |
| DIV_ROUND_UP(offsetof(OfDpaFlowKey, f) + sizeof(((OfDpaFlowKey *)0)->f), \ |
| sizeof(uint64_t)) |
| |
| typedef struct of_dpa_flow_action { |
| uint32_t goto_tbl; |
| struct { |
| uint32_t group_id; |
| uint32_t tun_log_lport; |
| __be16 vlan_id; |
| } write; |
| struct { |
| __be16 new_vlan_id; |
| uint32_t out_pport; |
| uint8_t copy_to_cpu; |
| __be16 vlan_id; |
| } apply; |
| } OfDpaFlowAction; |
| |
| typedef struct of_dpa_flow { |
| uint32_t lpm; |
| uint32_t priority; |
| uint32_t hardtime; |
| uint32_t idletime; |
| uint64_t cookie; |
| OfDpaFlowKey key; |
| OfDpaFlowKey mask; |
| OfDpaFlowAction action; |
| struct { |
| uint64_t hits; |
| int64_t install_time; |
| int64_t refresh_time; |
| uint64_t rx_pkts; |
| uint64_t tx_pkts; |
| } stats; |
| } OfDpaFlow; |
| |
| typedef struct of_dpa_flow_pkt_fields { |
| uint32_t tunnel_id; |
| struct eth_header *ethhdr; |
| __be16 *h_proto; |
| struct vlan_header *vlanhdr; |
| struct ip_header *ipv4hdr; |
| struct ip6_header *ipv6hdr; |
| Ipv6Addr *ipv6_src_addr; |
| Ipv6Addr *ipv6_dst_addr; |
| } OfDpaFlowPktFields; |
| |
| typedef struct of_dpa_flow_context { |
| uint32_t in_pport; |
| uint32_t tunnel_id; |
| struct iovec *iov; |
| int iovcnt; |
| struct eth_header ethhdr_rewrite; |
| struct vlan_header vlanhdr_rewrite; |
| struct vlan_header vlanhdr; |
| OfDpa *of_dpa; |
| OfDpaFlowPktFields fields; |
| OfDpaFlowAction action_set; |
| } OfDpaFlowContext; |
| |
| typedef struct of_dpa_flow_match { |
| OfDpaFlowKey value; |
| OfDpaFlow *best; |
| } OfDpaFlowMatch; |
| |
| typedef struct of_dpa_group { |
| uint32_t id; |
| union { |
| struct { |
| uint32_t out_pport; |
| uint8_t pop_vlan; |
| } l2_interface; |
| struct { |
| uint32_t group_id; |
| MACAddr src_mac; |
| MACAddr dst_mac; |
| __be16 vlan_id; |
| } l2_rewrite; |
| struct { |
| uint16_t group_count; |
| uint32_t *group_ids; |
| } l2_flood; |
| struct { |
| uint32_t group_id; |
| MACAddr src_mac; |
| MACAddr dst_mac; |
| __be16 vlan_id; |
| uint8_t ttl_check; |
| } l3_unicast; |
| }; |
| } OfDpaGroup; |
| |
| static int of_dpa_mask2prefix(__be32 mask) |
| { |
| int i; |
| int count = 32; |
| |
| for (i = 0; i < 32; i++) { |
| if (!(ntohl(mask) & ((2 << i) - 1))) { |
| count--; |
| } |
| } |
| |
| return count; |
| } |
| |
| #if defined(DEBUG_ROCKER) |
| static void of_dpa_flow_key_dump(OfDpaFlowKey *key, OfDpaFlowKey *mask) |
| { |
| char buf[512], *b = buf, *mac; |
| |
| b += sprintf(b, " tbl %2d", key->tbl_id); |
| |
| if (key->in_pport || (mask && mask->in_pport)) { |
| b += sprintf(b, " in_pport %2d", key->in_pport); |
| if (mask && mask->in_pport != 0xffffffff) { |
| b += sprintf(b, "/0x%08x", key->in_pport); |
| } |
| } |
| |
| if (key->tunnel_id || (mask && mask->tunnel_id)) { |
| b += sprintf(b, " tun %8d", key->tunnel_id); |
| if (mask && mask->tunnel_id != 0xffffffff) { |
| b += sprintf(b, "/0x%08x", key->tunnel_id); |
| } |
| } |
| |
| if (key->eth.vlan_id || (mask && mask->eth.vlan_id)) { |
| b += sprintf(b, " vlan %4d", ntohs(key->eth.vlan_id)); |
| if (mask && mask->eth.vlan_id != 0xffff) { |
| b += sprintf(b, "/0x%04x", ntohs(key->eth.vlan_id)); |
| } |
| } |
| |
| if (memcmp(key->eth.src.a, zero_mac.a, ETH_ALEN) || |
| (mask && memcmp(mask->eth.src.a, zero_mac.a, ETH_ALEN))) { |
| mac = qemu_mac_strdup_printf(key->eth.src.a); |
| b += sprintf(b, " src %s", mac); |
| g_free(mac); |
| if (mask && memcmp(mask->eth.src.a, ff_mac.a, ETH_ALEN)) { |
| mac = qemu_mac_strdup_printf(mask->eth.src.a); |
| b += sprintf(b, "/%s", mac); |
| g_free(mac); |
| } |
| } |
| |
| if (memcmp(key->eth.dst.a, zero_mac.a, ETH_ALEN) || |
| (mask && memcmp(mask->eth.dst.a, zero_mac.a, ETH_ALEN))) { |
| mac = qemu_mac_strdup_printf(key->eth.dst.a); |
| b += sprintf(b, " dst %s", mac); |
| g_free(mac); |
| if (mask && memcmp(mask->eth.dst.a, ff_mac.a, ETH_ALEN)) { |
| mac = qemu_mac_strdup_printf(mask->eth.dst.a); |
| b += sprintf(b, "/%s", mac); |
| g_free(mac); |
| } |
| } |
| |
| if (key->eth.type || (mask && mask->eth.type)) { |
| b += sprintf(b, " type 0x%04x", ntohs(key->eth.type)); |
| if (mask && mask->eth.type != 0xffff) { |
| b += sprintf(b, "/0x%04x", ntohs(mask->eth.type)); |
| } |
| switch (ntohs(key->eth.type)) { |
| case 0x0800: |
| case 0x86dd: |
| if (key->ip.proto || (mask && mask->ip.proto)) { |
| b += sprintf(b, " ip proto %2d", key->ip.proto); |
| if (mask && mask->ip.proto != 0xff) { |
| b += sprintf(b, "/0x%02x", mask->ip.proto); |
| } |
| } |
| if (key->ip.tos || (mask && mask->ip.tos)) { |
| b += sprintf(b, " ip tos %2d", key->ip.tos); |
| if (mask && mask->ip.tos != 0xff) { |
| b += sprintf(b, "/0x%02x", mask->ip.tos); |
| } |
| } |
| break; |
| } |
| switch (ntohs(key->eth.type)) { |
| case 0x0800: |
| if (key->ipv4.addr.dst || (mask && mask->ipv4.addr.dst)) { |
| b += sprintf(b, " dst %s", |
| inet_ntoa(*(struct in_addr *)&key->ipv4.addr.dst)); |
| if (mask) { |
| b += sprintf(b, "/%d", |
| of_dpa_mask2prefix(mask->ipv4.addr.dst)); |
| } |
| } |
| break; |
| } |
| } |
| |
| DPRINTF("%s\n", buf); |
| } |
| #else |
| #define of_dpa_flow_key_dump(k, m) |
| #endif |
| |
| static void _of_dpa_flow_match(void *key, void *value, void *user_data) |
| { |
| OfDpaFlow *flow = value; |
| OfDpaFlowMatch *match = user_data; |
| uint64_t *k = (uint64_t *)&flow->key; |
| uint64_t *m = (uint64_t *)&flow->mask; |
| uint64_t *v = (uint64_t *)&match->value; |
| int i; |
| |
| if (flow->key.tbl_id == match->value.tbl_id) { |
| of_dpa_flow_key_dump(&flow->key, &flow->mask); |
| } |
| |
| if (flow->key.width > match->value.width) { |
| return; |
| } |
| |
| for (i = 0; i < flow->key.width; i++, k++, m++, v++) { |
| if ((~*k & *m & *v) | (*k & *m & ~*v)) { |
| return; |
| } |
| } |
| |
| DPRINTF("match\n"); |
| |
| if (!match->best || |
| flow->priority > match->best->priority || |
| flow->lpm > match->best->lpm) { |
| match->best = flow; |
| } |
| } |
| |
| static OfDpaFlow *of_dpa_flow_match(OfDpa *of_dpa, OfDpaFlowMatch *match) |
| { |
| DPRINTF("\nnew search\n"); |
| of_dpa_flow_key_dump(&match->value, NULL); |
| |
| g_hash_table_foreach(of_dpa->flow_tbl, _of_dpa_flow_match, match); |
| |
| return match->best; |
| } |
| |
| static OfDpaFlow *of_dpa_flow_find(OfDpa *of_dpa, uint64_t cookie) |
| { |
| return g_hash_table_lookup(of_dpa->flow_tbl, &cookie); |
| } |
| |
| static int of_dpa_flow_add(OfDpa *of_dpa, OfDpaFlow *flow) |
| { |
| g_hash_table_insert(of_dpa->flow_tbl, &flow->cookie, flow); |
| |
| return ROCKER_OK; |
| } |
| |
| static void of_dpa_flow_del(OfDpa *of_dpa, OfDpaFlow *flow) |
| { |
| g_hash_table_remove(of_dpa->flow_tbl, &flow->cookie); |
| } |
| |
| static OfDpaFlow *of_dpa_flow_alloc(uint64_t cookie) |
| { |
| OfDpaFlow *flow; |
| int64_t now = qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) / 1000; |
| |
| flow = g_new0(OfDpaFlow, 1); |
| if (!flow) { |
| return NULL; |
| } |
| |
| flow->cookie = cookie; |
| flow->mask.tbl_id = 0xffffffff; |
| |
| flow->stats.install_time = flow->stats.refresh_time = now; |
| |
| return flow; |
| } |
| |
| static void of_dpa_flow_pkt_hdr_reset(OfDpaFlowContext *fc) |
| { |
| OfDpaFlowPktFields *fields = &fc->fields; |
| |
| fc->iov[0].iov_base = fields->ethhdr; |
| fc->iov[0].iov_len = sizeof(struct eth_header); |
| fc->iov[1].iov_base = fields->vlanhdr; |
| fc->iov[1].iov_len = fields->vlanhdr ? sizeof(struct vlan_header) : 0; |
| } |
| |
| static void of_dpa_flow_pkt_parse(OfDpaFlowContext *fc, |
| const struct iovec *iov, int iovcnt) |
| { |
| OfDpaFlowPktFields *fields = &fc->fields; |
| size_t sofar = 0; |
| int i; |
| |
| sofar += sizeof(struct eth_header); |
| if (iov->iov_len < sofar) { |
| DPRINTF("flow_pkt_parse underrun on eth_header\n"); |
| return; |
| } |
| |
| fields->ethhdr = iov->iov_base; |
| fields->h_proto = &fields->ethhdr->h_proto; |
| |
| if (ntohs(*fields->h_proto) == ETH_P_VLAN) { |
| sofar += sizeof(struct vlan_header); |
| if (iov->iov_len < sofar) { |
| DPRINTF("flow_pkt_parse underrun on vlan_header\n"); |
| return; |
| } |
| fields->vlanhdr = (struct vlan_header *)(fields->ethhdr + 1); |
| fields->h_proto = &fields->vlanhdr->h_proto; |
| } |
| |
| switch (ntohs(*fields->h_proto)) { |
| case ETH_P_IP: |
| sofar += sizeof(struct ip_header); |
| if (iov->iov_len < sofar) { |
| DPRINTF("flow_pkt_parse underrun on ip_header\n"); |
| return; |
| } |
| fields->ipv4hdr = (struct ip_header *)(fields->h_proto + 1); |
| break; |
| case ETH_P_IPV6: |
| sofar += sizeof(struct ip6_header); |
| if (iov->iov_len < sofar) { |
| DPRINTF("flow_pkt_parse underrun on ip6_header\n"); |
| return; |
| } |
| fields->ipv6hdr = (struct ip6_header *)(fields->h_proto + 1); |
| break; |
| } |
| |
| /* To facilitate (potential) VLAN tag insertion, Make a |
| * copy of the iov and insert two new vectors at the |
| * beginning for eth hdr and vlan hdr. No data is copied, |
| * just the vectors. |
| */ |
| |
| of_dpa_flow_pkt_hdr_reset(fc); |
| |
| fc->iov[2].iov_base = fields->h_proto + 1; |
| fc->iov[2].iov_len = iov->iov_len - fc->iov[0].iov_len - fc->iov[1].iov_len; |
| |
| for (i = 1; i < iovcnt; i++) { |
| fc->iov[i+2] = iov[i]; |
| } |
| |
| fc->iovcnt = iovcnt + 2; |
| } |
| |
| static void of_dpa_flow_pkt_insert_vlan(OfDpaFlowContext *fc, __be16 vlan_id) |
| { |
| OfDpaFlowPktFields *fields = &fc->fields; |
| uint16_t h_proto = fields->ethhdr->h_proto; |
| |
| if (fields->vlanhdr) { |
| DPRINTF("flow_pkt_insert_vlan packet already has vlan\n"); |
| return; |
| } |
| |
| fields->ethhdr->h_proto = htons(ETH_P_VLAN); |
| fields->vlanhdr = &fc->vlanhdr; |
| fields->vlanhdr->h_tci = vlan_id; |
| fields->vlanhdr->h_proto = h_proto; |
| fields->h_proto = &fields->vlanhdr->h_proto; |
| |
| fc->iov[1].iov_base = fields->vlanhdr; |
| fc->iov[1].iov_len = sizeof(struct vlan_header); |
| } |
| |
| static void of_dpa_flow_pkt_strip_vlan(OfDpaFlowContext *fc) |
| { |
| OfDpaFlowPktFields *fields = &fc->fields; |
| |
| if (!fields->vlanhdr) { |
| return; |
| } |
| |
| fc->iov[0].iov_len -= sizeof(fields->ethhdr->h_proto); |
| fc->iov[1].iov_base = fields->h_proto; |
| fc->iov[1].iov_len = sizeof(fields->ethhdr->h_proto); |
| } |
| |
| static void of_dpa_flow_pkt_hdr_rewrite(OfDpaFlowContext *fc, |
| uint8_t *src_mac, uint8_t *dst_mac, |
| __be16 vlan_id) |
| { |
| OfDpaFlowPktFields *fields = &fc->fields; |
| |
| if (src_mac || dst_mac) { |
| memcpy(&fc->ethhdr_rewrite, fields->ethhdr, sizeof(struct eth_header)); |
| if (src_mac && memcmp(src_mac, zero_mac.a, ETH_ALEN)) { |
| memcpy(fc->ethhdr_rewrite.h_source, src_mac, ETH_ALEN); |
| } |
| if (dst_mac && memcmp(dst_mac, zero_mac.a, ETH_ALEN)) { |
| memcpy(fc->ethhdr_rewrite.h_dest, dst_mac, ETH_ALEN); |
| } |
| fc->iov[0].iov_base = &fc->ethhdr_rewrite; |
| } |
| |
| if (vlan_id && fields->vlanhdr) { |
| fc->vlanhdr_rewrite = fc->vlanhdr; |
| fc->vlanhdr_rewrite.h_tci = vlan_id; |
| fc->iov[1].iov_base = &fc->vlanhdr_rewrite; |
| } |
| } |
| |
| static void of_dpa_flow_ig_tbl(OfDpaFlowContext *fc, uint32_t tbl_id); |
| |
| static void of_dpa_ig_port_build_match(OfDpaFlowContext *fc, |
| OfDpaFlowMatch *match) |
| { |
| match->value.tbl_id = ROCKER_OF_DPA_TABLE_ID_INGRESS_PORT; |
| match->value.in_pport = fc->in_pport; |
| match->value.width = FLOW_KEY_WIDTH(tbl_id); |
| } |
| |
| static void of_dpa_ig_port_miss(OfDpaFlowContext *fc) |
| { |
| uint32_t port; |
| |
| /* The default on miss is for packets from physical ports |
| * to go to the VLAN Flow Table. There is no default rule |
| * for packets from logical ports, which are dropped on miss. |
| */ |
| |
| if (fp_port_from_pport(fc->in_pport, &port)) { |
| of_dpa_flow_ig_tbl(fc, ROCKER_OF_DPA_TABLE_ID_VLAN); |
| } |
| } |
| |
| static void of_dpa_vlan_build_match(OfDpaFlowContext *fc, |
| OfDpaFlowMatch *match) |
| { |
| match->value.tbl_id = ROCKER_OF_DPA_TABLE_ID_VLAN; |
| match->value.in_pport = fc->in_pport; |
| if (fc->fields.vlanhdr) { |
| match->value.eth.vlan_id = fc->fields.vlanhdr->h_tci; |
| } |
| match->value.width = FLOW_KEY_WIDTH(eth.vlan_id); |
| } |
| |
| static void of_dpa_vlan_insert(OfDpaFlowContext *fc, |
| OfDpaFlow *flow) |
| { |
| if (flow->action.apply.new_vlan_id) { |
| of_dpa_flow_pkt_insert_vlan(fc, flow->action.apply.new_vlan_id); |
| } |
| } |
| |
| static void of_dpa_term_mac_build_match(OfDpaFlowContext *fc, |
| OfDpaFlowMatch *match) |
| { |
| match->value.tbl_id = ROCKER_OF_DPA_TABLE_ID_TERMINATION_MAC; |
| match->value.in_pport = fc->in_pport; |
| match->value.eth.type = *fc->fields.h_proto; |
| match->value.eth.vlan_id = fc->fields.vlanhdr->h_tci; |
| memcpy(match->value.eth.dst.a, fc->fields.ethhdr->h_dest, |
| sizeof(match->value.eth.dst.a)); |
| match->value.width = FLOW_KEY_WIDTH(eth.type); |
| } |
| |
| static void of_dpa_term_mac_miss(OfDpaFlowContext *fc) |
| { |
| of_dpa_flow_ig_tbl(fc, ROCKER_OF_DPA_TABLE_ID_BRIDGING); |
| } |
| |
| static void of_dpa_apply_actions(OfDpaFlowContext *fc, |
| OfDpaFlow *flow) |
| { |
| fc->action_set.apply.copy_to_cpu = flow->action.apply.copy_to_cpu; |
| fc->action_set.apply.vlan_id = flow->key.eth.vlan_id; |
| } |
| |
| static void of_dpa_bridging_build_match(OfDpaFlowContext *fc, |
| OfDpaFlowMatch *match) |
| { |
| match->value.tbl_id = ROCKER_OF_DPA_TABLE_ID_BRIDGING; |
| if (fc->fields.vlanhdr) { |
| match->value.eth.vlan_id = fc->fields.vlanhdr->h_tci; |
| } else if (fc->tunnel_id) { |
| match->value.tunnel_id = fc->tunnel_id; |
| } |
| memcpy(match->value.eth.dst.a, fc->fields.ethhdr->h_dest, |
| sizeof(match->value.eth.dst.a)); |
| match->value.width = FLOW_KEY_WIDTH(eth.dst); |
| } |
| |
| static void of_dpa_bridging_learn(OfDpaFlowContext *fc, |
| OfDpaFlow *dst_flow) |
| { |
| OfDpaFlowMatch match = { { 0, }, }; |
| OfDpaFlow *flow; |
| uint8_t *addr; |
| uint16_t vlan_id; |
| int64_t now = qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) / 1000; |
| int64_t refresh_delay = 1; |
| |
| /* Do a lookup in bridge table by src_mac/vlan */ |
| |
| addr = fc->fields.ethhdr->h_source; |
| vlan_id = fc->fields.vlanhdr->h_tci; |
| |
| match.value.tbl_id = ROCKER_OF_DPA_TABLE_ID_BRIDGING; |
| match.value.eth.vlan_id = vlan_id; |
| memcpy(match.value.eth.dst.a, addr, sizeof(match.value.eth.dst.a)); |
| match.value.width = FLOW_KEY_WIDTH(eth.dst); |
| |
| flow = of_dpa_flow_match(fc->of_dpa, &match); |
| if (flow) { |
| if (!memcmp(flow->mask.eth.dst.a, ff_mac.a, |
| sizeof(flow->mask.eth.dst.a))) { |
| /* src_mac/vlan already learned; if in_port and out_port |
| * don't match, the end station has moved and the port |
| * needs updating */ |
| /* XXX implement the in_port/out_port check */ |
| if (now - flow->stats.refresh_time < refresh_delay) { |
| return; |
| } |
| flow->stats.refresh_time = now; |
| } |
| } |
| |
| /* Let driver know about mac/vlan. This may be a new mac/vlan |
| * or a refresh of existing mac/vlan that's been hit after the |
| * refresh_delay. |
| */ |
| |
| rocker_event_mac_vlan_seen(world_rocker(fc->of_dpa->world), |
| fc->in_pport, addr, vlan_id); |
| } |
| |
| static void of_dpa_bridging_miss(OfDpaFlowContext *fc) |
| { |
| of_dpa_bridging_learn(fc, NULL); |
| of_dpa_flow_ig_tbl(fc, ROCKER_OF_DPA_TABLE_ID_ACL_POLICY); |
| } |
| |
| static void of_dpa_bridging_action_write(OfDpaFlowContext *fc, |
| OfDpaFlow *flow) |
| { |
| if (flow->action.write.group_id != ROCKER_GROUP_NONE) { |
| fc->action_set.write.group_id = flow->action.write.group_id; |
| } |
| fc->action_set.write.tun_log_lport = flow->action.write.tun_log_lport; |
| } |
| |
| static void of_dpa_unicast_routing_build_match(OfDpaFlowContext *fc, |
| OfDpaFlowMatch *match) |
| { |
| match->value.tbl_id = ROCKER_OF_DPA_TABLE_ID_UNICAST_ROUTING; |
| match->value.eth.type = *fc->fields.h_proto; |
| if (fc->fields.ipv4hdr) { |
| match->value.ipv4.addr.dst = fc->fields.ipv4hdr->ip_dst; |
| } |
| if (fc->fields.ipv6_dst_addr) { |
| memcpy(&match->value.ipv6.addr.dst, fc->fields.ipv6_dst_addr, |
| sizeof(match->value.ipv6.addr.dst)); |
| } |
| match->value.width = FLOW_KEY_WIDTH(ipv6.addr.dst); |
| } |
| |
| static void of_dpa_unicast_routing_miss(OfDpaFlowContext *fc) |
| { |
| of_dpa_flow_ig_tbl(fc, ROCKER_OF_DPA_TABLE_ID_ACL_POLICY); |
| } |
| |
| static void of_dpa_unicast_routing_action_write(OfDpaFlowContext *fc, |
| OfDpaFlow *flow) |
| { |
| if (flow->action.write.group_id != ROCKER_GROUP_NONE) { |
| fc->action_set.write.group_id = flow->action.write.group_id; |
| } |
| } |
| |
| static void |
| of_dpa_multicast_routing_build_match(OfDpaFlowContext *fc, |
| OfDpaFlowMatch *match) |
| { |
| match->value.tbl_id = ROCKER_OF_DPA_TABLE_ID_MULTICAST_ROUTING; |
| match->value.eth.type = *fc->fields.h_proto; |
| match->value.eth.vlan_id = fc->fields.vlanhdr->h_tci; |
| if (fc->fields.ipv4hdr) { |
| match->value.ipv4.addr.src = fc->fields.ipv4hdr->ip_src; |
| match->value.ipv4.addr.dst = fc->fields.ipv4hdr->ip_dst; |
| } |
| if (fc->fields.ipv6_src_addr) { |
| memcpy(&match->value.ipv6.addr.src, fc->fields.ipv6_src_addr, |
| sizeof(match->value.ipv6.addr.src)); |
| } |
| if (fc->fields.ipv6_dst_addr) { |
| memcpy(&match->value.ipv6.addr.dst, fc->fields.ipv6_dst_addr, |
| sizeof(match->value.ipv6.addr.dst)); |
| } |
| match->value.width = FLOW_KEY_WIDTH(ipv6.addr.dst); |
| } |
| |
| static void of_dpa_multicast_routing_miss(OfDpaFlowContext *fc) |
| { |
| of_dpa_flow_ig_tbl(fc, ROCKER_OF_DPA_TABLE_ID_ACL_POLICY); |
| } |
| |
| static void |
| of_dpa_multicast_routing_action_write(OfDpaFlowContext *fc, |
| OfDpaFlow *flow) |
| { |
| if (flow->action.write.group_id != ROCKER_GROUP_NONE) { |
| fc->action_set.write.group_id = flow->action.write.group_id; |
| } |
| fc->action_set.write.vlan_id = flow->action.write.vlan_id; |
| } |
| |
| static void of_dpa_acl_build_match(OfDpaFlowContext *fc, |
| OfDpaFlowMatch *match) |
| { |
| match->value.tbl_id = ROCKER_OF_DPA_TABLE_ID_ACL_POLICY; |
| match->value.in_pport = fc->in_pport; |
| memcpy(match->value.eth.src.a, fc->fields.ethhdr->h_source, |
| sizeof(match->value.eth.src.a)); |
| memcpy(match->value.eth.dst.a, fc->fields.ethhdr->h_dest, |
| sizeof(match->value.eth.dst.a)); |
| match->value.eth.type = *fc->fields.h_proto; |
| match->value.eth.vlan_id = fc->fields.vlanhdr->h_tci; |
| match->value.width = FLOW_KEY_WIDTH(eth.type); |
| if (fc->fields.ipv4hdr) { |
| match->value.ip.proto = fc->fields.ipv4hdr->ip_p; |
| match->value.ip.tos = fc->fields.ipv4hdr->ip_tos; |
| match->value.width = FLOW_KEY_WIDTH(ip.tos); |
| } else if (fc->fields.ipv6hdr) { |
| match->value.ip.proto = |
| fc->fields.ipv6hdr->ip6_ctlun.ip6_un1.ip6_un1_nxt; |
| match->value.ip.tos = 0; /* XXX what goes here? */ |
| match->value.width = FLOW_KEY_WIDTH(ip.tos); |
| } |
| } |
| |
| static void of_dpa_eg(OfDpaFlowContext *fc); |
| static void of_dpa_acl_hit(OfDpaFlowContext *fc, |
| OfDpaFlow *dst_flow) |
| { |
| of_dpa_eg(fc); |
| } |
| |
| static void of_dpa_acl_action_write(OfDpaFlowContext *fc, |
| OfDpaFlow *flow) |
| { |
| if (flow->action.write.group_id != ROCKER_GROUP_NONE) { |
| fc->action_set.write.group_id = flow->action.write.group_id; |
| } |
| } |
| |
| static void of_dpa_drop(OfDpaFlowContext *fc) |
| { |
| /* drop packet */ |
| } |
| |
| static OfDpaGroup *of_dpa_group_find(OfDpa *of_dpa, |
| uint32_t group_id) |
| { |
| return g_hash_table_lookup(of_dpa->group_tbl, &group_id); |
| } |
| |
| static int of_dpa_group_add(OfDpa *of_dpa, OfDpaGroup *group) |
| { |
| g_hash_table_insert(of_dpa->group_tbl, &group->id, group); |
| |
| return 0; |
| } |
| |
| #if 0 |
| static int of_dpa_group_mod(OfDpa *of_dpa, OfDpaGroup *group) |
| { |
| OfDpaGroup *old_group = of_dpa_group_find(of_dpa, group->id); |
| |
| if (!old_group) { |
| return -ENOENT; |
| } |
| |
| /* XXX */ |
| |
| return 0; |
| } |
| #endif |
| |
| static int of_dpa_group_del(OfDpa *of_dpa, OfDpaGroup *group) |
| { |
| g_hash_table_remove(of_dpa->group_tbl, &group->id); |
| |
| return 0; |
| } |
| |
| #if 0 |
| static int of_dpa_group_get_stats(OfDpa *of_dpa, uint32_t id) |
| { |
| OfDpaGroup *group = of_dpa_group_find(of_dpa, id); |
| |
| if (!group) { |
| return -ENOENT; |
| } |
| |
| /* XXX get/return stats */ |
| |
| return 0; |
| } |
| #endif |
| |
| static OfDpaGroup *of_dpa_group_alloc(uint32_t id) |
| { |
| OfDpaGroup *group = g_new0(OfDpaGroup, 1); |
| |
| if (!group) { |
| return NULL; |
| } |
| |
| group->id = id; |
| |
| return group; |
| } |
| |
| static void of_dpa_output_l2_interface(OfDpaFlowContext *fc, |
| OfDpaGroup *group) |
| { |
| uint8_t copy_to_cpu = fc->action_set.apply.copy_to_cpu; |
| |
| if (group->l2_interface.pop_vlan) { |
| of_dpa_flow_pkt_strip_vlan(fc); |
| } |
| |
| /* Note: By default, and as per the OpenFlow 1.3.1 |
| * specification, a packet cannot be forwarded back |
| * to the IN_PORT from which it came in. An action |
| * bucket that specifies the particular packet's |
| * egress port is not evaluated. |
| */ |
| |
| if (group->l2_interface.out_pport == 0) { |
| rx_produce(fc->of_dpa->world, fc->in_pport, fc->iov, fc->iovcnt, |
| copy_to_cpu); |
| } else if (group->l2_interface.out_pport != fc->in_pport) { |
| rocker_port_eg(world_rocker(fc->of_dpa->world), |
| group->l2_interface.out_pport, |
| fc->iov, fc->iovcnt); |
| } |
| } |
| |
| static void of_dpa_output_l2_rewrite(OfDpaFlowContext *fc, |
| OfDpaGroup *group) |
| { |
| OfDpaGroup *l2_group = |
| of_dpa_group_find(fc->of_dpa, group->l2_rewrite.group_id); |
| |
| if (!l2_group) { |
| return; |
| } |
| |
| of_dpa_flow_pkt_hdr_rewrite(fc, group->l2_rewrite.src_mac.a, |
| group->l2_rewrite.dst_mac.a, |
| group->l2_rewrite.vlan_id); |
| of_dpa_output_l2_interface(fc, l2_group); |
| } |
| |
| static void of_dpa_output_l2_flood(OfDpaFlowContext *fc, |
| OfDpaGroup *group) |
| { |
| OfDpaGroup *l2_group; |
| int i; |
| |
| for (i = 0; i < group->l2_flood.group_count; i++) { |
| of_dpa_flow_pkt_hdr_reset(fc); |
| l2_group = of_dpa_group_find(fc->of_dpa, group->l2_flood.group_ids[i]); |
| if (!l2_group) { |
| continue; |
| } |
| switch (ROCKER_GROUP_TYPE_GET(l2_group->id)) { |
| case ROCKER_OF_DPA_GROUP_TYPE_L2_INTERFACE: |
| of_dpa_output_l2_interface(fc, l2_group); |
| break; |
| case ROCKER_OF_DPA_GROUP_TYPE_L2_REWRITE: |
| of_dpa_output_l2_rewrite(fc, l2_group); |
| break; |
| } |
| } |
| } |
| |
| static void of_dpa_output_l3_unicast(OfDpaFlowContext *fc, OfDpaGroup *group) |
| { |
| OfDpaGroup *l2_group = |
| of_dpa_group_find(fc->of_dpa, group->l3_unicast.group_id); |
| |
| if (!l2_group) { |
| return; |
| } |
| |
| of_dpa_flow_pkt_hdr_rewrite(fc, group->l3_unicast.src_mac.a, |
| group->l3_unicast.dst_mac.a, |
| group->l3_unicast.vlan_id); |
| /* XXX need ttl_check */ |
| of_dpa_output_l2_interface(fc, l2_group); |
| } |
| |
| static void of_dpa_eg(OfDpaFlowContext *fc) |
| { |
| OfDpaFlowAction *set = &fc->action_set; |
| OfDpaGroup *group; |
| uint32_t group_id; |
| |
| /* send a copy of pkt to CPU (controller)? */ |
| |
| if (set->apply.copy_to_cpu) { |
| group_id = ROCKER_GROUP_L2_INTERFACE(set->apply.vlan_id, 0); |
| group = of_dpa_group_find(fc->of_dpa, group_id); |
| if (group) { |
| of_dpa_output_l2_interface(fc, group); |
| of_dpa_flow_pkt_hdr_reset(fc); |
| } |
| } |
| |
| /* process group write actions */ |
| |
| if (!set->write.group_id) { |
| return; |
| } |
| |
| group = of_dpa_group_find(fc->of_dpa, set->write.group_id); |
| if (!group) { |
| return; |
| } |
| |
| switch (ROCKER_GROUP_TYPE_GET(group->id)) { |
| case ROCKER_OF_DPA_GROUP_TYPE_L2_INTERFACE: |
| of_dpa_output_l2_interface(fc, group); |
| break; |
| case ROCKER_OF_DPA_GROUP_TYPE_L2_REWRITE: |
| of_dpa_output_l2_rewrite(fc, group); |
| break; |
| case ROCKER_OF_DPA_GROUP_TYPE_L2_FLOOD: |
| case ROCKER_OF_DPA_GROUP_TYPE_L2_MCAST: |
| of_dpa_output_l2_flood(fc, group); |
| break; |
| case ROCKER_OF_DPA_GROUP_TYPE_L3_UCAST: |
| of_dpa_output_l3_unicast(fc, group); |
| break; |
| } |
| } |
| |
| typedef struct of_dpa_flow_tbl_ops { |
| void (*build_match)(OfDpaFlowContext *fc, OfDpaFlowMatch *match); |
| void (*hit)(OfDpaFlowContext *fc, OfDpaFlow *flow); |
| void (*miss)(OfDpaFlowContext *fc); |
| void (*hit_no_goto)(OfDpaFlowContext *fc); |
| void (*action_apply)(OfDpaFlowContext *fc, OfDpaFlow *flow); |
| void (*action_write)(OfDpaFlowContext *fc, OfDpaFlow *flow); |
| } OfDpaFlowTblOps; |
| |
| static OfDpaFlowTblOps of_dpa_tbl_ops[] = { |
| [ROCKER_OF_DPA_TABLE_ID_INGRESS_PORT] = { |
| .build_match = of_dpa_ig_port_build_match, |
| .miss = of_dpa_ig_port_miss, |
| .hit_no_goto = of_dpa_drop, |
| }, |
| [ROCKER_OF_DPA_TABLE_ID_VLAN] = { |
| .build_match = of_dpa_vlan_build_match, |
| .hit_no_goto = of_dpa_drop, |
| .action_apply = of_dpa_vlan_insert, |
| }, |
| [ROCKER_OF_DPA_TABLE_ID_TERMINATION_MAC] = { |
| .build_match = of_dpa_term_mac_build_match, |
| .miss = of_dpa_term_mac_miss, |
| .hit_no_goto = of_dpa_drop, |
| .action_apply = of_dpa_apply_actions, |
| }, |
| [ROCKER_OF_DPA_TABLE_ID_BRIDGING] = { |
| .build_match = of_dpa_bridging_build_match, |
| .hit = of_dpa_bridging_learn, |
| .miss = of_dpa_bridging_miss, |
| .hit_no_goto = of_dpa_drop, |
| .action_apply = of_dpa_apply_actions, |
| .action_write = of_dpa_bridging_action_write, |
| }, |
| [ROCKER_OF_DPA_TABLE_ID_UNICAST_ROUTING] = { |
| .build_match = of_dpa_unicast_routing_build_match, |
| .miss = of_dpa_unicast_routing_miss, |
| .hit_no_goto = of_dpa_drop, |
| .action_write = of_dpa_unicast_routing_action_write, |
| }, |
| [ROCKER_OF_DPA_TABLE_ID_MULTICAST_ROUTING] = { |
| .build_match = of_dpa_multicast_routing_build_match, |
| .miss = of_dpa_multicast_routing_miss, |
| .hit_no_goto = of_dpa_drop, |
| .action_write = of_dpa_multicast_routing_action_write, |
| }, |
| [ROCKER_OF_DPA_TABLE_ID_ACL_POLICY] = { |
| .build_match = of_dpa_acl_build_match, |
| .hit = of_dpa_acl_hit, |
| .miss = of_dpa_eg, |
| .action_apply = of_dpa_apply_actions, |
| .action_write = of_dpa_acl_action_write, |
| }, |
| }; |
| |
| static void of_dpa_flow_ig_tbl(OfDpaFlowContext *fc, uint32_t tbl_id) |
| { |
| OfDpaFlowTblOps *ops = &of_dpa_tbl_ops[tbl_id]; |
| OfDpaFlowMatch match = { { 0, }, }; |
| OfDpaFlow *flow; |
| |
| if (ops->build_match) { |
| ops->build_match(fc, &match); |
| } else { |
| return; |
| } |
| |
| flow = of_dpa_flow_match(fc->of_dpa, &match); |
| if (!flow) { |
| if (ops->miss) { |
| ops->miss(fc); |
| } |
| return; |
| } |
| |
| flow->stats.hits++; |
| |
| if (ops->action_apply) { |
| ops->action_apply(fc, flow); |
| } |
| |
| if (ops->action_write) { |
| ops->action_write(fc, flow); |
| } |
| |
| if (ops->hit) { |
| ops->hit(fc, flow); |
| } |
| |
| if (flow->action.goto_tbl) { |
| of_dpa_flow_ig_tbl(fc, flow->action.goto_tbl); |
| } else if (ops->hit_no_goto) { |
| ops->hit_no_goto(fc); |
| } |
| |
| /* drop packet */ |
| } |
| |
| static ssize_t of_dpa_ig(World *world, uint32_t pport, |
| const struct iovec *iov, int iovcnt) |
| { |
| struct iovec iov_copy[iovcnt + 2]; |
| OfDpaFlowContext fc = { |
| .of_dpa = world_private(world), |
| .in_pport = pport, |
| .iov = iov_copy, |
| .iovcnt = iovcnt + 2, |
| }; |
| |
| of_dpa_flow_pkt_parse(&fc, iov, iovcnt); |
| of_dpa_flow_ig_tbl(&fc, ROCKER_OF_DPA_TABLE_ID_INGRESS_PORT); |
| |
| return iov_size(iov, iovcnt); |
| } |
| |
| #define ROCKER_TUNNEL_LPORT 0x00010000 |
| |
| static int of_dpa_cmd_add_ig_port(OfDpaFlow *flow, RockerTlv **flow_tlvs) |
| { |
| OfDpaFlowKey *key = &flow->key; |
| OfDpaFlowKey *mask = &flow->mask; |
| OfDpaFlowAction *action = &flow->action; |
| bool overlay_tunnel; |
| |
| if (!flow_tlvs[ROCKER_TLV_OF_DPA_IN_PPORT] || |
| !flow_tlvs[ROCKER_TLV_OF_DPA_GOTO_TABLE_ID]) { |
| return -ROCKER_EINVAL; |
| } |
| |
| key->tbl_id = ROCKER_OF_DPA_TABLE_ID_INGRESS_PORT; |
| key->width = FLOW_KEY_WIDTH(tbl_id); |
| |
| key->in_pport = rocker_tlv_get_le32(flow_tlvs[ROCKER_TLV_OF_DPA_IN_PPORT]); |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_IN_PPORT_MASK]) { |
| mask->in_pport = |
| rocker_tlv_get_le32(flow_tlvs[ROCKER_TLV_OF_DPA_IN_PPORT_MASK]); |
| } |
| |
| overlay_tunnel = !!(key->in_pport & ROCKER_TUNNEL_LPORT); |
| |
| action->goto_tbl = |
| rocker_tlv_get_le16(flow_tlvs[ROCKER_TLV_OF_DPA_GOTO_TABLE_ID]); |
| |
| if (!overlay_tunnel && action->goto_tbl != ROCKER_OF_DPA_TABLE_ID_VLAN) { |
| return -ROCKER_EINVAL; |
| } |
| |
| if (overlay_tunnel && action->goto_tbl != ROCKER_OF_DPA_TABLE_ID_BRIDGING) { |
| return -ROCKER_EINVAL; |
| } |
| |
| return ROCKER_OK; |
| } |
| |
| static int of_dpa_cmd_add_vlan(OfDpaFlow *flow, RockerTlv **flow_tlvs) |
| { |
| OfDpaFlowKey *key = &flow->key; |
| OfDpaFlowKey *mask = &flow->mask; |
| OfDpaFlowAction *action = &flow->action; |
| uint32_t port; |
| bool untagged; |
| |
| if (!flow_tlvs[ROCKER_TLV_OF_DPA_IN_PPORT] || |
| !flow_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID]) { |
| DPRINTF("Must give in_pport and vlan_id to install VLAN tbl entry\n"); |
| return -ROCKER_EINVAL; |
| } |
| |
| key->tbl_id = ROCKER_OF_DPA_TABLE_ID_VLAN; |
| key->width = FLOW_KEY_WIDTH(eth.vlan_id); |
| |
| key->in_pport = rocker_tlv_get_le32(flow_tlvs[ROCKER_TLV_OF_DPA_IN_PPORT]); |
| if (!fp_port_from_pport(key->in_pport, &port)) { |
| DPRINTF("in_pport (%d) not a front-panel port\n", key->in_pport); |
| return -ROCKER_EINVAL; |
| } |
| mask->in_pport = 0xffffffff; |
| |
| key->eth.vlan_id = rocker_tlv_get_u16(flow_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID]); |
| |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID_MASK]) { |
| mask->eth.vlan_id = |
| rocker_tlv_get_u16(flow_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID_MASK]); |
| } |
| |
| if (key->eth.vlan_id) { |
| untagged = false; /* filtering */ |
| } else { |
| untagged = true; |
| } |
| |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_GOTO_TABLE_ID]) { |
| action->goto_tbl = |
| rocker_tlv_get_le16(flow_tlvs[ROCKER_TLV_OF_DPA_GOTO_TABLE_ID]); |
| if (action->goto_tbl != ROCKER_OF_DPA_TABLE_ID_TERMINATION_MAC) { |
| DPRINTF("Goto tbl (%d) must be TERM_MAC\n", action->goto_tbl); |
| return -ROCKER_EINVAL; |
| } |
| } |
| |
| if (untagged) { |
| if (!flow_tlvs[ROCKER_TLV_OF_DPA_NEW_VLAN_ID]) { |
| DPRINTF("Must specify new vlan_id if untagged\n"); |
| return -ROCKER_EINVAL; |
| } |
| action->apply.new_vlan_id = |
| rocker_tlv_get_u16(flow_tlvs[ROCKER_TLV_OF_DPA_NEW_VLAN_ID]); |
| if (1 > ntohs(action->apply.new_vlan_id) || |
| ntohs(action->apply.new_vlan_id) > 4095) { |
| DPRINTF("New vlan_id (%d) must be between 1 and 4095\n", |
| ntohs(action->apply.new_vlan_id)); |
| return -ROCKER_EINVAL; |
| } |
| } |
| |
| return ROCKER_OK; |
| } |
| |
| static int of_dpa_cmd_add_term_mac(OfDpaFlow *flow, RockerTlv **flow_tlvs) |
| { |
| OfDpaFlowKey *key = &flow->key; |
| OfDpaFlowKey *mask = &flow->mask; |
| OfDpaFlowAction *action = &flow->action; |
| const MACAddr ipv4_mcast = { .a = { 0x01, 0x00, 0x5e, 0x00, 0x00, 0x00 } }; |
| const MACAddr ipv4_mask = { .a = { 0xff, 0xff, 0xff, 0x80, 0x00, 0x00 } }; |
| const MACAddr ipv6_mcast = { .a = { 0x33, 0x33, 0x00, 0x00, 0x00, 0x00 } }; |
| const MACAddr ipv6_mask = { .a = { 0xff, 0xff, 0x00, 0x00, 0x00, 0x00 } }; |
| uint32_t port; |
| bool unicast = false; |
| bool multicast = false; |
| |
| if (!flow_tlvs[ROCKER_TLV_OF_DPA_IN_PPORT] || |
| !flow_tlvs[ROCKER_TLV_OF_DPA_IN_PPORT_MASK] || |
| !flow_tlvs[ROCKER_TLV_OF_DPA_ETHERTYPE] || |
| !flow_tlvs[ROCKER_TLV_OF_DPA_DST_MAC] || |
| !flow_tlvs[ROCKER_TLV_OF_DPA_DST_MAC_MASK] || |
| !flow_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID] || |
| !flow_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID_MASK]) { |
| return -ROCKER_EINVAL; |
| } |
| |
| key->tbl_id = ROCKER_OF_DPA_TABLE_ID_TERMINATION_MAC; |
| key->width = FLOW_KEY_WIDTH(eth.type); |
| |
| key->in_pport = rocker_tlv_get_le32(flow_tlvs[ROCKER_TLV_OF_DPA_IN_PPORT]); |
| if (!fp_port_from_pport(key->in_pport, &port)) { |
| return -ROCKER_EINVAL; |
| } |
| mask->in_pport = |
| rocker_tlv_get_le32(flow_tlvs[ROCKER_TLV_OF_DPA_IN_PPORT_MASK]); |
| |
| key->eth.type = rocker_tlv_get_u16(flow_tlvs[ROCKER_TLV_OF_DPA_ETHERTYPE]); |
| if (key->eth.type != htons(0x0800) && key->eth.type != htons(0x86dd)) { |
| return -ROCKER_EINVAL; |
| } |
| mask->eth.type = htons(0xffff); |
| |
| memcpy(key->eth.dst.a, |
| rocker_tlv_data(flow_tlvs[ROCKER_TLV_OF_DPA_DST_MAC]), |
| sizeof(key->eth.dst.a)); |
| memcpy(mask->eth.dst.a, |
| rocker_tlv_data(flow_tlvs[ROCKER_TLV_OF_DPA_DST_MAC_MASK]), |
| sizeof(mask->eth.dst.a)); |
| |
| if ((key->eth.dst.a[0] & 0x01) == 0x00) { |
| unicast = true; |
| } |
| |
| /* only two wildcard rules are acceptable for IPv4 and IPv6 multicast */ |
| if (memcmp(key->eth.dst.a, ipv4_mcast.a, sizeof(key->eth.dst.a)) == 0 && |
| memcmp(mask->eth.dst.a, ipv4_mask.a, sizeof(mask->eth.dst.a)) == 0) { |
| multicast = true; |
| } |
| if (memcmp(key->eth.dst.a, ipv6_mcast.a, sizeof(key->eth.dst.a)) == 0 && |
| memcmp(mask->eth.dst.a, ipv6_mask.a, sizeof(mask->eth.dst.a)) == 0) { |
| multicast = true; |
| } |
| |
| if (!unicast && !multicast) { |
| return -ROCKER_EINVAL; |
| } |
| |
| key->eth.vlan_id = rocker_tlv_get_u16(flow_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID]); |
| mask->eth.vlan_id = |
| rocker_tlv_get_u16(flow_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID_MASK]); |
| |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_GOTO_TABLE_ID]) { |
| action->goto_tbl = |
| rocker_tlv_get_le16(flow_tlvs[ROCKER_TLV_OF_DPA_GOTO_TABLE_ID]); |
| |
| if (action->goto_tbl != ROCKER_OF_DPA_TABLE_ID_UNICAST_ROUTING && |
| action->goto_tbl != ROCKER_OF_DPA_TABLE_ID_MULTICAST_ROUTING) { |
| return -ROCKER_EINVAL; |
| } |
| |
| if (unicast && |
| action->goto_tbl != ROCKER_OF_DPA_TABLE_ID_UNICAST_ROUTING) { |
| return -ROCKER_EINVAL; |
| } |
| |
| if (multicast && |
| action->goto_tbl != ROCKER_OF_DPA_TABLE_ID_MULTICAST_ROUTING) { |
| return -ROCKER_EINVAL; |
| } |
| } |
| |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_COPY_CPU_ACTION]) { |
| action->apply.copy_to_cpu = |
| rocker_tlv_get_u8(flow_tlvs[ROCKER_TLV_OF_DPA_COPY_CPU_ACTION]); |
| } |
| |
| return ROCKER_OK; |
| } |
| |
| static int of_dpa_cmd_add_bridging(OfDpaFlow *flow, RockerTlv **flow_tlvs) |
| { |
| OfDpaFlowKey *key = &flow->key; |
| OfDpaFlowKey *mask = &flow->mask; |
| OfDpaFlowAction *action = &flow->action; |
| bool unicast = false; |
| bool dst_mac = false; |
| bool dst_mac_mask = false; |
| enum { |
| BRIDGING_MODE_UNKNOWN, |
| BRIDGING_MODE_VLAN_UCAST, |
| BRIDGING_MODE_VLAN_MCAST, |
| BRIDGING_MODE_VLAN_DFLT, |
| BRIDGING_MODE_TUNNEL_UCAST, |
| BRIDGING_MODE_TUNNEL_MCAST, |
| BRIDGING_MODE_TUNNEL_DFLT, |
| } mode = BRIDGING_MODE_UNKNOWN; |
| |
| key->tbl_id = ROCKER_OF_DPA_TABLE_ID_BRIDGING; |
| |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID]) { |
| key->eth.vlan_id = |
| rocker_tlv_get_u16(flow_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID]); |
| mask->eth.vlan_id = 0xffff; |
| key->width = FLOW_KEY_WIDTH(eth.vlan_id); |
| } |
| |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_TUNNEL_ID]) { |
| key->tunnel_id = |
| rocker_tlv_get_le32(flow_tlvs[ROCKER_TLV_OF_DPA_TUNNEL_ID]); |
| mask->tunnel_id = 0xffffffff; |
| key->width = FLOW_KEY_WIDTH(tunnel_id); |
| } |
| |
| /* can't do VLAN bridging and tunnel bridging at same time */ |
| if (key->eth.vlan_id && key->tunnel_id) { |
| DPRINTF("can't do VLAN bridging and tunnel bridging at same time\n"); |
| return -ROCKER_EINVAL; |
| } |
| |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_DST_MAC]) { |
| memcpy(key->eth.dst.a, |
| rocker_tlv_data(flow_tlvs[ROCKER_TLV_OF_DPA_DST_MAC]), |
| sizeof(key->eth.dst.a)); |
| key->width = FLOW_KEY_WIDTH(eth.dst); |
| dst_mac = true; |
| unicast = (key->eth.dst.a[0] & 0x01) == 0x00; |
| } |
| |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_DST_MAC_MASK]) { |
| memcpy(mask->eth.dst.a, |
| rocker_tlv_data(flow_tlvs[ROCKER_TLV_OF_DPA_DST_MAC_MASK]), |
| sizeof(mask->eth.dst.a)); |
| key->width = FLOW_KEY_WIDTH(eth.dst); |
| dst_mac_mask = true; |
| } else if (flow_tlvs[ROCKER_TLV_OF_DPA_DST_MAC]) { |
| memcpy(mask->eth.dst.a, ff_mac.a, sizeof(mask->eth.dst.a)); |
| } |
| |
| if (key->eth.vlan_id) { |
| if (dst_mac && !dst_mac_mask) { |
| mode = unicast ? BRIDGING_MODE_VLAN_UCAST : |
| BRIDGING_MODE_VLAN_MCAST; |
| } else if ((dst_mac && dst_mac_mask) || !dst_mac) { |
| mode = BRIDGING_MODE_VLAN_DFLT; |
| } |
| } else if (key->tunnel_id) { |
| if (dst_mac && !dst_mac_mask) { |
| mode = unicast ? BRIDGING_MODE_TUNNEL_UCAST : |
| BRIDGING_MODE_TUNNEL_MCAST; |
| } else if ((dst_mac && dst_mac_mask) || !dst_mac) { |
| mode = BRIDGING_MODE_TUNNEL_DFLT; |
| } |
| } |
| |
| if (mode == BRIDGING_MODE_UNKNOWN) { |
| DPRINTF("Unknown bridging mode\n"); |
| return -ROCKER_EINVAL; |
| } |
| |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_GOTO_TABLE_ID]) { |
| action->goto_tbl = |
| rocker_tlv_get_le16(flow_tlvs[ROCKER_TLV_OF_DPA_GOTO_TABLE_ID]); |
| if (action->goto_tbl != ROCKER_OF_DPA_TABLE_ID_ACL_POLICY) { |
| DPRINTF("Briding goto tbl must be ACL policy\n"); |
| return -ROCKER_EINVAL; |
| } |
| } |
| |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_GROUP_ID]) { |
| action->write.group_id = |
| rocker_tlv_get_le32(flow_tlvs[ROCKER_TLV_OF_DPA_GROUP_ID]); |
| switch (mode) { |
| case BRIDGING_MODE_VLAN_UCAST: |
| if (ROCKER_GROUP_TYPE_GET(action->write.group_id) != |
| ROCKER_OF_DPA_GROUP_TYPE_L2_INTERFACE) { |
| DPRINTF("Bridging mode vlan ucast needs L2 " |
| "interface group (0x%08x)\n", |
| action->write.group_id); |
| return -ROCKER_EINVAL; |
| } |
| break; |
| case BRIDGING_MODE_VLAN_MCAST: |
| if (ROCKER_GROUP_TYPE_GET(action->write.group_id) != |
| ROCKER_OF_DPA_GROUP_TYPE_L2_MCAST) { |
| DPRINTF("Bridging mode vlan mcast needs L2 " |
| "mcast group (0x%08x)\n", |
| action->write.group_id); |
| return -ROCKER_EINVAL; |
| } |
| break; |
| case BRIDGING_MODE_VLAN_DFLT: |
| if (ROCKER_GROUP_TYPE_GET(action->write.group_id) != |
| ROCKER_OF_DPA_GROUP_TYPE_L2_FLOOD) { |
| DPRINTF("Bridging mode vlan dflt needs L2 " |
| "flood group (0x%08x)\n", |
| action->write.group_id); |
| return -ROCKER_EINVAL; |
| } |
| break; |
| case BRIDGING_MODE_TUNNEL_MCAST: |
| if (ROCKER_GROUP_TYPE_GET(action->write.group_id) != |
| ROCKER_OF_DPA_GROUP_TYPE_L2_OVERLAY) { |
| DPRINTF("Bridging mode tunnel mcast needs L2 " |
| "overlay group (0x%08x)\n", |
| action->write.group_id); |
| return -ROCKER_EINVAL; |
| } |
| break; |
| case BRIDGING_MODE_TUNNEL_DFLT: |
| if (ROCKER_GROUP_TYPE_GET(action->write.group_id) != |
| ROCKER_OF_DPA_GROUP_TYPE_L2_OVERLAY) { |
| DPRINTF("Bridging mode tunnel dflt needs L2 " |
| "overlay group (0x%08x)\n", |
| action->write.group_id); |
| return -ROCKER_EINVAL; |
| } |
| break; |
| default: |
| return -ROCKER_EINVAL; |
| } |
| } |
| |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_TUNNEL_LPORT]) { |
| action->write.tun_log_lport = |
| rocker_tlv_get_le32(flow_tlvs[ROCKER_TLV_OF_DPA_TUNNEL_LPORT]); |
| if (mode != BRIDGING_MODE_TUNNEL_UCAST) { |
| DPRINTF("Have tunnel logical port but not " |
| "in bridging tunnel mode\n"); |
| return -ROCKER_EINVAL; |
| } |
| } |
| |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_COPY_CPU_ACTION]) { |
| action->apply.copy_to_cpu = |
| rocker_tlv_get_u8(flow_tlvs[ROCKER_TLV_OF_DPA_COPY_CPU_ACTION]); |
| } |
| |
| return ROCKER_OK; |
| } |
| |
| static int of_dpa_cmd_add_unicast_routing(OfDpaFlow *flow, |
| RockerTlv **flow_tlvs) |
| { |
| OfDpaFlowKey *key = &flow->key; |
| OfDpaFlowKey *mask = &flow->mask; |
| OfDpaFlowAction *action = &flow->action; |
| enum { |
| UNICAST_ROUTING_MODE_UNKNOWN, |
| UNICAST_ROUTING_MODE_IPV4, |
| UNICAST_ROUTING_MODE_IPV6, |
| } mode = UNICAST_ROUTING_MODE_UNKNOWN; |
| uint8_t type; |
| |
| if (!flow_tlvs[ROCKER_TLV_OF_DPA_ETHERTYPE]) { |
| return -ROCKER_EINVAL; |
| } |
| |
| key->tbl_id = ROCKER_OF_DPA_TABLE_ID_UNICAST_ROUTING; |
| key->width = FLOW_KEY_WIDTH(ipv6.addr.dst); |
| |
| key->eth.type = rocker_tlv_get_u16(flow_tlvs[ROCKER_TLV_OF_DPA_ETHERTYPE]); |
| switch (ntohs(key->eth.type)) { |
| case 0x0800: |
| mode = UNICAST_ROUTING_MODE_IPV4; |
| break; |
| case 0x86dd: |
| mode = UNICAST_ROUTING_MODE_IPV6; |
| break; |
| default: |
| return -ROCKER_EINVAL; |
| } |
| mask->eth.type = htons(0xffff); |
| |
| switch (mode) { |
| case UNICAST_ROUTING_MODE_IPV4: |
| if (!flow_tlvs[ROCKER_TLV_OF_DPA_DST_IP]) { |
| return -ROCKER_EINVAL; |
| } |
| key->ipv4.addr.dst = |
| rocker_tlv_get_u32(flow_tlvs[ROCKER_TLV_OF_DPA_DST_IP]); |
| if (ipv4_addr_is_multicast(key->ipv4.addr.dst)) { |
| return -ROCKER_EINVAL; |
| } |
| flow->lpm = of_dpa_mask2prefix(htonl(0xffffffff)); |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_DST_IP_MASK]) { |
| mask->ipv4.addr.dst = |
| rocker_tlv_get_u32(flow_tlvs[ROCKER_TLV_OF_DPA_DST_IP_MASK]); |
| flow->lpm = of_dpa_mask2prefix(mask->ipv4.addr.dst); |
| } |
| break; |
| case UNICAST_ROUTING_MODE_IPV6: |
| if (!flow_tlvs[ROCKER_TLV_OF_DPA_DST_IPV6]) { |
| return -ROCKER_EINVAL; |
| } |
| memcpy(&key->ipv6.addr.dst, |
| rocker_tlv_data(flow_tlvs[ROCKER_TLV_OF_DPA_DST_IPV6]), |
| sizeof(key->ipv6.addr.dst)); |
| if (ipv6_addr_is_multicast(&key->ipv6.addr.dst)) { |
| return -ROCKER_EINVAL; |
| } |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_DST_IPV6_MASK]) { |
| memcpy(&mask->ipv6.addr.dst, |
| rocker_tlv_data(flow_tlvs[ROCKER_TLV_OF_DPA_DST_IPV6_MASK]), |
| sizeof(mask->ipv6.addr.dst)); |
| } |
| break; |
| default: |
| return -ROCKER_EINVAL; |
| } |
| |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_GOTO_TABLE_ID]) { |
| action->goto_tbl = |
| rocker_tlv_get_le16(flow_tlvs[ROCKER_TLV_OF_DPA_GOTO_TABLE_ID]); |
| if (action->goto_tbl != ROCKER_OF_DPA_TABLE_ID_ACL_POLICY) { |
| return -ROCKER_EINVAL; |
| } |
| } |
| |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_GROUP_ID]) { |
| action->write.group_id = |
| rocker_tlv_get_le32(flow_tlvs[ROCKER_TLV_OF_DPA_GROUP_ID]); |
| type = ROCKER_GROUP_TYPE_GET(action->write.group_id); |
| if (type != ROCKER_OF_DPA_GROUP_TYPE_L2_INTERFACE && |
| type != ROCKER_OF_DPA_GROUP_TYPE_L3_UCAST && |
| type != ROCKER_OF_DPA_GROUP_TYPE_L3_ECMP) { |
| return -ROCKER_EINVAL; |
| } |
| } |
| |
| return ROCKER_OK; |
| } |
| |
| static int of_dpa_cmd_add_multicast_routing(OfDpaFlow *flow, |
| RockerTlv **flow_tlvs) |
| { |
| OfDpaFlowKey *key = &flow->key; |
| OfDpaFlowKey *mask = &flow->mask; |
| OfDpaFlowAction *action = &flow->action; |
| enum { |
| MULTICAST_ROUTING_MODE_UNKNOWN, |
| MULTICAST_ROUTING_MODE_IPV4, |
| MULTICAST_ROUTING_MODE_IPV6, |
| } mode = MULTICAST_ROUTING_MODE_UNKNOWN; |
| |
| if (!flow_tlvs[ROCKER_TLV_OF_DPA_ETHERTYPE] || |
| !flow_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID]) { |
| return -ROCKER_EINVAL; |
| } |
| |
| key->tbl_id = ROCKER_OF_DPA_TABLE_ID_MULTICAST_ROUTING; |
| key->width = FLOW_KEY_WIDTH(ipv6.addr.dst); |
| |
| key->eth.type = rocker_tlv_get_u16(flow_tlvs[ROCKER_TLV_OF_DPA_ETHERTYPE]); |
| switch (ntohs(key->eth.type)) { |
| case 0x0800: |
| mode = MULTICAST_ROUTING_MODE_IPV4; |
| break; |
| case 0x86dd: |
| mode = MULTICAST_ROUTING_MODE_IPV6; |
| break; |
| default: |
| return -ROCKER_EINVAL; |
| } |
| |
| key->eth.vlan_id = rocker_tlv_get_u16(flow_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID]); |
| |
| switch (mode) { |
| case MULTICAST_ROUTING_MODE_IPV4: |
| |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_SRC_IP]) { |
| key->ipv4.addr.src = |
| rocker_tlv_get_u32(flow_tlvs[ROCKER_TLV_OF_DPA_SRC_IP]); |
| } |
| |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_SRC_IP_MASK]) { |
| mask->ipv4.addr.src = |
| rocker_tlv_get_u32(flow_tlvs[ROCKER_TLV_OF_DPA_SRC_IP_MASK]); |
| } |
| |
| if (!flow_tlvs[ROCKER_TLV_OF_DPA_SRC_IP]) { |
| if (mask->ipv4.addr.src != 0) { |
| return -ROCKER_EINVAL; |
| } |
| } |
| |
| if (!flow_tlvs[ROCKER_TLV_OF_DPA_DST_IP]) { |
| return -ROCKER_EINVAL; |
| } |
| |
| key->ipv4.addr.dst = |
| rocker_tlv_get_u32(flow_tlvs[ROCKER_TLV_OF_DPA_DST_IP]); |
| if (!ipv4_addr_is_multicast(key->ipv4.addr.dst)) { |
| return -ROCKER_EINVAL; |
| } |
| |
| break; |
| |
| case MULTICAST_ROUTING_MODE_IPV6: |
| |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_SRC_IPV6]) { |
| memcpy(&key->ipv6.addr.src, |
| rocker_tlv_data(flow_tlvs[ROCKER_TLV_OF_DPA_SRC_IPV6]), |
| sizeof(key->ipv6.addr.src)); |
| } |
| |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_SRC_IPV6_MASK]) { |
| memcpy(&mask->ipv6.addr.src, |
| rocker_tlv_data(flow_tlvs[ROCKER_TLV_OF_DPA_SRC_IPV6_MASK]), |
| sizeof(mask->ipv6.addr.src)); |
| } |
| |
| if (!flow_tlvs[ROCKER_TLV_OF_DPA_SRC_IPV6]) { |
| if (mask->ipv6.addr.src.addr32[0] != 0 && |
| mask->ipv6.addr.src.addr32[1] != 0 && |
| mask->ipv6.addr.src.addr32[2] != 0 && |
| mask->ipv6.addr.src.addr32[3] != 0) { |
| return -ROCKER_EINVAL; |
| } |
| } |
| |
| if (!flow_tlvs[ROCKER_TLV_OF_DPA_DST_IPV6]) { |
| return -ROCKER_EINVAL; |
| } |
| |
| memcpy(&key->ipv6.addr.dst, |
| rocker_tlv_data(flow_tlvs[ROCKER_TLV_OF_DPA_DST_IPV6]), |
| sizeof(key->ipv6.addr.dst)); |
| if (!ipv6_addr_is_multicast(&key->ipv6.addr.dst)) { |
| return -ROCKER_EINVAL; |
| } |
| |
| break; |
| |
| default: |
| return -ROCKER_EINVAL; |
| } |
| |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_GOTO_TABLE_ID]) { |
| action->goto_tbl = |
| rocker_tlv_get_le16(flow_tlvs[ROCKER_TLV_OF_DPA_GOTO_TABLE_ID]); |
| if (action->goto_tbl != ROCKER_OF_DPA_TABLE_ID_ACL_POLICY) { |
| return -ROCKER_EINVAL; |
| } |
| } |
| |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_GROUP_ID]) { |
| action->write.group_id = |
| rocker_tlv_get_le32(flow_tlvs[ROCKER_TLV_OF_DPA_GROUP_ID]); |
| if (ROCKER_GROUP_TYPE_GET(action->write.group_id) != |
| ROCKER_OF_DPA_GROUP_TYPE_L3_MCAST) { |
| return -ROCKER_EINVAL; |
| } |
| action->write.vlan_id = key->eth.vlan_id; |
| } |
| |
| return ROCKER_OK; |
| } |
| |
| static int of_dpa_cmd_add_acl_ip(OfDpaFlowKey *key, OfDpaFlowKey *mask, |
| RockerTlv **flow_tlvs) |
| { |
| key->width = FLOW_KEY_WIDTH(ip.tos); |
| |
| key->ip.proto = 0; |
| key->ip.tos = 0; |
| mask->ip.proto = 0; |
| mask->ip.tos = 0; |
| |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_IP_PROTO]) { |
| key->ip.proto = |
| rocker_tlv_get_u8(flow_tlvs[ROCKER_TLV_OF_DPA_IP_PROTO]); |
| } |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_IP_PROTO_MASK]) { |
| mask->ip.proto = |
| rocker_tlv_get_u8(flow_tlvs[ROCKER_TLV_OF_DPA_IP_PROTO_MASK]); |
| } |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_IP_DSCP]) { |
| key->ip.tos = |
| rocker_tlv_get_u8(flow_tlvs[ROCKER_TLV_OF_DPA_IP_DSCP]); |
| } |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_IP_DSCP_MASK]) { |
| mask->ip.tos = |
| rocker_tlv_get_u8(flow_tlvs[ROCKER_TLV_OF_DPA_IP_DSCP_MASK]); |
| } |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_IP_ECN]) { |
| key->ip.tos |= |
| rocker_tlv_get_u8(flow_tlvs[ROCKER_TLV_OF_DPA_IP_ECN]) << 6; |
| } |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_IP_ECN_MASK]) { |
| mask->ip.tos |= |
| rocker_tlv_get_u8(flow_tlvs[ROCKER_TLV_OF_DPA_IP_ECN_MASK]) << 6; |
| } |
| |
| return ROCKER_OK; |
| } |
| |
| static int of_dpa_cmd_add_acl(OfDpaFlow *flow, RockerTlv **flow_tlvs) |
| { |
| OfDpaFlowKey *key = &flow->key; |
| OfDpaFlowKey *mask = &flow->mask; |
| OfDpaFlowAction *action = &flow->action; |
| enum { |
| ACL_MODE_UNKNOWN, |
| ACL_MODE_IPV4_VLAN, |
| ACL_MODE_IPV6_VLAN, |
| ACL_MODE_IPV4_TENANT, |
| ACL_MODE_IPV6_TENANT, |
| ACL_MODE_NON_IP_VLAN, |
| ACL_MODE_NON_IP_TENANT, |
| ACL_MODE_ANY_VLAN, |
| ACL_MODE_ANY_TENANT, |
| } mode = ACL_MODE_UNKNOWN; |
| int err = ROCKER_OK; |
| |
| if (!flow_tlvs[ROCKER_TLV_OF_DPA_IN_PPORT] || |
| !flow_tlvs[ROCKER_TLV_OF_DPA_ETHERTYPE]) { |
| return -ROCKER_EINVAL; |
| } |
| |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID] && |
| flow_tlvs[ROCKER_TLV_OF_DPA_TUNNEL_ID]) { |
| return -ROCKER_EINVAL; |
| } |
| |
| key->tbl_id = ROCKER_OF_DPA_TABLE_ID_ACL_POLICY; |
| key->width = FLOW_KEY_WIDTH(eth.type); |
| |
| key->in_pport = rocker_tlv_get_le32(flow_tlvs[ROCKER_TLV_OF_DPA_IN_PPORT]); |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_IN_PPORT_MASK]) { |
| mask->in_pport = |
| rocker_tlv_get_le32(flow_tlvs[ROCKER_TLV_OF_DPA_IN_PPORT_MASK]); |
| } |
| |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_SRC_MAC]) { |
| memcpy(key->eth.src.a, |
| rocker_tlv_data(flow_tlvs[ROCKER_TLV_OF_DPA_SRC_MAC]), |
| sizeof(key->eth.src.a)); |
| } |
| |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_SRC_MAC_MASK]) { |
| memcpy(mask->eth.src.a, |
| rocker_tlv_data(flow_tlvs[ROCKER_TLV_OF_DPA_SRC_MAC_MASK]), |
| sizeof(mask->eth.src.a)); |
| } |
| |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_DST_MAC]) { |
| memcpy(key->eth.dst.a, |
| rocker_tlv_data(flow_tlvs[ROCKER_TLV_OF_DPA_DST_MAC]), |
| sizeof(key->eth.dst.a)); |
| } |
| |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_DST_MAC_MASK]) { |
| memcpy(mask->eth.dst.a, |
| rocker_tlv_data(flow_tlvs[ROCKER_TLV_OF_DPA_DST_MAC_MASK]), |
| sizeof(mask->eth.dst.a)); |
| } |
| |
| key->eth.type = rocker_tlv_get_u16(flow_tlvs[ROCKER_TLV_OF_DPA_ETHERTYPE]); |
| if (key->eth.type) { |
| mask->eth.type = 0xffff; |
| } |
| |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID]) { |
| key->eth.vlan_id = |
| rocker_tlv_get_u16(flow_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID]); |
| } |
| |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID_MASK]) { |
| mask->eth.vlan_id = |
| rocker_tlv_get_u16(flow_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID_MASK]); |
| } |
| |
| switch (ntohs(key->eth.type)) { |
| case 0x0000: |
| mode = (key->eth.vlan_id) ? ACL_MODE_ANY_VLAN : ACL_MODE_ANY_TENANT; |
| break; |
| case 0x0800: |
| mode = (key->eth.vlan_id) ? ACL_MODE_IPV4_VLAN : ACL_MODE_IPV4_TENANT; |
| break; |
| case 0x86dd: |
| mode = (key->eth.vlan_id) ? ACL_MODE_IPV6_VLAN : ACL_MODE_IPV6_TENANT; |
| break; |
| default: |
| mode = (key->eth.vlan_id) ? ACL_MODE_NON_IP_VLAN : |
| ACL_MODE_NON_IP_TENANT; |
| break; |
| } |
| |
| /* XXX only supporting VLAN modes for now */ |
| if (mode != ACL_MODE_IPV4_VLAN && |
| mode != ACL_MODE_IPV6_VLAN && |
| mode != ACL_MODE_NON_IP_VLAN && |
| mode != ACL_MODE_ANY_VLAN) { |
| return -ROCKER_EINVAL; |
| } |
| |
| switch (ntohs(key->eth.type)) { |
| case 0x0800: |
| case 0x86dd: |
| err = of_dpa_cmd_add_acl_ip(key, mask, flow_tlvs); |
| break; |
| } |
| |
| if (err) { |
| return err; |
| } |
| |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_GROUP_ID]) { |
| action->write.group_id = |
| rocker_tlv_get_le32(flow_tlvs[ROCKER_TLV_OF_DPA_GROUP_ID]); |
| } |
| |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_COPY_CPU_ACTION]) { |
| action->apply.copy_to_cpu = |
| rocker_tlv_get_u8(flow_tlvs[ROCKER_TLV_OF_DPA_COPY_CPU_ACTION]); |
| } |
| |
| return ROCKER_OK; |
| } |
| |
| static int of_dpa_cmd_flow_add_mod(OfDpa *of_dpa, OfDpaFlow *flow, |
| RockerTlv **flow_tlvs) |
| { |
| enum rocker_of_dpa_table_id tbl; |
| int err = ROCKER_OK; |
| |
| if (!flow_tlvs[ROCKER_TLV_OF_DPA_TABLE_ID] || |
| !flow_tlvs[ROCKER_TLV_OF_DPA_PRIORITY] || |
| !flow_tlvs[ROCKER_TLV_OF_DPA_HARDTIME]) { |
| return -ROCKER_EINVAL; |
| } |
| |
| tbl = rocker_tlv_get_le16(flow_tlvs[ROCKER_TLV_OF_DPA_TABLE_ID]); |
| flow->priority = rocker_tlv_get_le32(flow_tlvs[ROCKER_TLV_OF_DPA_PRIORITY]); |
| flow->hardtime = rocker_tlv_get_le32(flow_tlvs[ROCKER_TLV_OF_DPA_HARDTIME]); |
| |
| if (flow_tlvs[ROCKER_TLV_OF_DPA_IDLETIME]) { |
| if (tbl == ROCKER_OF_DPA_TABLE_ID_INGRESS_PORT || |
| tbl == ROCKER_OF_DPA_TABLE_ID_VLAN || |
| tbl == ROCKER_OF_DPA_TABLE_ID_TERMINATION_MAC) { |
| return -ROCKER_EINVAL; |
| } |
| flow->idletime = |
| rocker_tlv_get_le32(flow_tlvs[ROCKER_TLV_OF_DPA_IDLETIME]); |
| } |
| |
| switch (tbl) { |
| case ROCKER_OF_DPA_TABLE_ID_INGRESS_PORT: |
| err = of_dpa_cmd_add_ig_port(flow, flow_tlvs); |
| break; |
| case ROCKER_OF_DPA_TABLE_ID_VLAN: |
| err = of_dpa_cmd_add_vlan(flow, flow_tlvs); |
| break; |
| case ROCKER_OF_DPA_TABLE_ID_TERMINATION_MAC: |
| err = of_dpa_cmd_add_term_mac(flow, flow_tlvs); |
| break; |
| case ROCKER_OF_DPA_TABLE_ID_BRIDGING: |
| err = of_dpa_cmd_add_bridging(flow, flow_tlvs); |
| break; |
| case ROCKER_OF_DPA_TABLE_ID_UNICAST_ROUTING: |
| err = of_dpa_cmd_add_unicast_routing(flow, flow_tlvs); |
| break; |
| case ROCKER_OF_DPA_TABLE_ID_MULTICAST_ROUTING: |
| err = of_dpa_cmd_add_multicast_routing(flow, flow_tlvs); |
| break; |
| case ROCKER_OF_DPA_TABLE_ID_ACL_POLICY: |
| err = of_dpa_cmd_add_acl(flow, flow_tlvs); |
| break; |
| } |
| |
| return err; |
| } |
| |
| static int of_dpa_cmd_flow_add(OfDpa *of_dpa, uint64_t cookie, |
| RockerTlv **flow_tlvs) |
| { |
| OfDpaFlow *flow = of_dpa_flow_find(of_dpa, cookie); |
| int err = ROCKER_OK; |
| |
| if (flow) { |
| return -ROCKER_EEXIST; |
| } |
| |
| flow = of_dpa_flow_alloc(cookie); |
| if (!flow) { |
| return -ROCKER_ENOMEM; |
| } |
| |
| err = of_dpa_cmd_flow_add_mod(of_dpa, flow, flow_tlvs); |
| if (err) { |
| g_free(flow); |
| return err; |
| } |
| |
| return of_dpa_flow_add(of_dpa, flow); |
| } |
| |
| static int of_dpa_cmd_flow_mod(OfDpa *of_dpa, uint64_t cookie, |
| RockerTlv **flow_tlvs) |
| { |
| OfDpaFlow *flow = of_dpa_flow_find(of_dpa, cookie); |
| |
| if (!flow) { |
| return -ROCKER_ENOENT; |
| } |
| |
| return of_dpa_cmd_flow_add_mod(of_dpa, flow, flow_tlvs); |
| } |
| |
| static int of_dpa_cmd_flow_del(OfDpa *of_dpa, uint64_t cookie) |
| { |
| OfDpaFlow *flow = of_dpa_flow_find(of_dpa, cookie); |
| |
| if (!flow) { |
| return -ROCKER_ENOENT; |
| } |
| |
| of_dpa_flow_del(of_dpa, flow); |
| |
| return ROCKER_OK; |
| } |
| |
| static int of_dpa_cmd_flow_get_stats(OfDpa *of_dpa, uint64_t cookie, |
| struct desc_info *info, char *buf) |
| { |
| OfDpaFlow *flow = of_dpa_flow_find(of_dpa, cookie); |
| size_t tlv_size; |
| int64_t now = qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) / 1000; |
| int pos; |
| |
| if (!flow) { |
| return -ROCKER_ENOENT; |
| } |
| |
| tlv_size = rocker_tlv_total_size(sizeof(uint32_t)) + /* duration */ |
| rocker_tlv_total_size(sizeof(uint64_t)) + /* rx_pkts */ |
| rocker_tlv_total_size(sizeof(uint64_t)); /* tx_ptks */ |
| |
| if (tlv_size > desc_buf_size(info)) { |
| return -ROCKER_EMSGSIZE; |
| } |
| |
| pos = 0; |
| rocker_tlv_put_le32(buf, &pos, ROCKER_TLV_OF_DPA_FLOW_STAT_DURATION, |
| (int32_t)(now - flow->stats.install_time)); |
| rocker_tlv_put_le64(buf, &pos, ROCKER_TLV_OF_DPA_FLOW_STAT_RX_PKTS, |
| flow->stats.rx_pkts); |
| rocker_tlv_put_le64(buf, &pos, ROCKER_TLV_OF_DPA_FLOW_STAT_TX_PKTS, |
| flow->stats.tx_pkts); |
| |
| return desc_set_buf(info, tlv_size); |
| } |
| |
| static int of_dpa_flow_cmd(OfDpa *of_dpa, struct desc_info *info, |
| char *buf, uint16_t cmd, |
| RockerTlv **flow_tlvs) |
| { |
| uint64_t cookie; |
| |
| if (!flow_tlvs[ROCKER_TLV_OF_DPA_COOKIE]) { |
| return -ROCKER_EINVAL; |
| } |
| |
| cookie = rocker_tlv_get_le64(flow_tlvs[ROCKER_TLV_OF_DPA_COOKIE]); |
| |
| switch (cmd) { |
| case ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_ADD: |
| return of_dpa_cmd_flow_add(of_dpa, cookie, flow_tlvs); |
| case ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_MOD: |
| return of_dpa_cmd_flow_mod(of_dpa, cookie, flow_tlvs); |
| case ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_DEL: |
| return of_dpa_cmd_flow_del(of_dpa, cookie); |
| case ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_GET_STATS: |
| return of_dpa_cmd_flow_get_stats(of_dpa, cookie, info, buf); |
| } |
| |
| return -ROCKER_ENOTSUP; |
| } |
| |
| static int of_dpa_cmd_add_l2_interface(OfDpaGroup *group, |
| RockerTlv **group_tlvs) |
| { |
| if (!group_tlvs[ROCKER_TLV_OF_DPA_OUT_PPORT] || |
| !group_tlvs[ROCKER_TLV_OF_DPA_POP_VLAN]) { |
| return -ROCKER_EINVAL; |
| } |
| |
| group->l2_interface.out_pport = |
| rocker_tlv_get_le32(group_tlvs[ROCKER_TLV_OF_DPA_OUT_PPORT]); |
| group->l2_interface.pop_vlan = |
| rocker_tlv_get_u8(group_tlvs[ROCKER_TLV_OF_DPA_POP_VLAN]); |
| |
| return ROCKER_OK; |
| } |
| |
| static int of_dpa_cmd_add_l2_rewrite(OfDpa *of_dpa, OfDpaGroup *group, |
| RockerTlv **group_tlvs) |
| { |
| OfDpaGroup *l2_interface_group; |
| |
| if (!group_tlvs[ROCKER_TLV_OF_DPA_GROUP_ID_LOWER]) { |
| return -ROCKER_EINVAL; |
| } |
| |
| group->l2_rewrite.group_id = |
| rocker_tlv_get_le32(group_tlvs[ROCKER_TLV_OF_DPA_GROUP_ID_LOWER]); |
| |
| l2_interface_group = of_dpa_group_find(of_dpa, group->l2_rewrite.group_id); |
| if (!l2_interface_group || |
| ROCKER_GROUP_TYPE_GET(l2_interface_group->id) != |
| ROCKER_OF_DPA_GROUP_TYPE_L2_INTERFACE) { |
| DPRINTF("l2 rewrite group needs a valid l2 interface group\n"); |
| return -ROCKER_EINVAL; |
| } |
| |
| if (group_tlvs[ROCKER_TLV_OF_DPA_SRC_MAC]) { |
| memcpy(group->l2_rewrite.src_mac.a, |
| rocker_tlv_data(group_tlvs[ROCKER_TLV_OF_DPA_SRC_MAC]), |
| sizeof(group->l2_rewrite.src_mac.a)); |
| } |
| |
| if (group_tlvs[ROCKER_TLV_OF_DPA_DST_MAC]) { |
| memcpy(group->l2_rewrite.dst_mac.a, |
| rocker_tlv_data(group_tlvs[ROCKER_TLV_OF_DPA_DST_MAC]), |
| sizeof(group->l2_rewrite.dst_mac.a)); |
| } |
| |
| if (group_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID]) { |
| group->l2_rewrite.vlan_id = |
| rocker_tlv_get_u16(group_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID]); |
| if (ROCKER_GROUP_VLAN_GET(l2_interface_group->id) != |
| (ntohs(group->l2_rewrite.vlan_id) & VLAN_VID_MASK)) { |
| DPRINTF("Set VLAN ID must be same as L2 interface group\n"); |
| return -ROCKER_EINVAL; |
| } |
| } |
| |
| return ROCKER_OK; |
| } |
| |
| static int of_dpa_cmd_add_l2_flood(OfDpa *of_dpa, OfDpaGroup *group, |
| RockerTlv **group_tlvs) |
| { |
| OfDpaGroup *l2_group; |
| RockerTlv **tlvs; |
| int err; |
| int i; |
| |
| if (!group_tlvs[ROCKER_TLV_OF_DPA_GROUP_COUNT] || |
| !group_tlvs[ROCKER_TLV_OF_DPA_GROUP_IDS]) { |
| return -ROCKER_EINVAL; |
| } |
| |
| group->l2_flood.group_count = |
| rocker_tlv_get_le16(group_tlvs[ROCKER_TLV_OF_DPA_GROUP_COUNT]); |
| |
| tlvs = g_new0(RockerTlv *, group->l2_flood.group_count + 1); |
| if (!tlvs) { |
| return -ROCKER_ENOMEM; |
| } |
| |
| g_free(group->l2_flood.group_ids); |
| group->l2_flood.group_ids = |
| g_new0(uint32_t, group->l2_flood.group_count); |
| if (!group->l2_flood.group_ids) { |
| err = -ROCKER_ENOMEM; |
| goto err_out; |
| } |
| |
| rocker_tlv_parse_nested(tlvs, group->l2_flood.group_count, |
| group_tlvs[ROCKER_TLV_OF_DPA_GROUP_IDS]); |
| |
| for (i = 0; i < group->l2_flood.group_count; i++) { |
| group->l2_flood.group_ids[i] = rocker_tlv_get_le32(tlvs[i + 1]); |
| } |
| |
| /* All of the L2 interface groups referenced by the L2 flood |
| * must have same VLAN |
| */ |
| |
| for (i = 0; i < group->l2_flood.group_count; i++) { |
| l2_group = of_dpa_group_find(of_dpa, group->l2_flood.group_ids[i]); |
| if (!l2_group) { |
| continue; |
| } |
| if ((ROCKER_GROUP_TYPE_GET(l2_group->id) == |
| ROCKER_OF_DPA_GROUP_TYPE_L2_INTERFACE) && |
| (ROCKER_GROUP_VLAN_GET(l2_group->id) != |
| ROCKER_GROUP_VLAN_GET(group->id))) { |
| DPRINTF("l2 interface group 0x%08x VLAN doesn't match l2 " |
| "flood group 0x%08x\n", |
| group->l2_flood.group_ids[i], group->id); |
| err = -ROCKER_EINVAL; |
| goto err_out; |
| } |
| } |
| |
| g_free(tlvs); |
| return ROCKER_OK; |
| |
| err_out: |
| group->l2_flood.group_count = 0; |
| g_free(group->l2_flood.group_ids); |
| g_free(tlvs); |
| |
| return err; |
| } |
| |
| static int of_dpa_cmd_add_l3_unicast(OfDpaGroup *group, RockerTlv **group_tlvs) |
| { |
| if (!group_tlvs[ROCKER_TLV_OF_DPA_GROUP_ID_LOWER]) { |
| return -ROCKER_EINVAL; |
| } |
| |
| group->l3_unicast.group_id = |
| rocker_tlv_get_le32(group_tlvs[ROCKER_TLV_OF_DPA_GROUP_ID_LOWER]); |
| |
| if (group_tlvs[ROCKER_TLV_OF_DPA_SRC_MAC]) { |
| memcpy(group->l3_unicast.src_mac.a, |
| rocker_tlv_data(group_tlvs[ROCKER_TLV_OF_DPA_SRC_MAC]), |
| sizeof(group->l3_unicast.src_mac.a)); |
| } |
| |
| if (group_tlvs[ROCKER_TLV_OF_DPA_DST_MAC]) { |
| memcpy(group->l3_unicast.dst_mac.a, |
| rocker_tlv_data(group_tlvs[ROCKER_TLV_OF_DPA_DST_MAC]), |
| sizeof(group->l3_unicast.dst_mac.a)); |
| } |
| |
| if (group_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID]) { |
| group->l3_unicast.vlan_id = |
| rocker_tlv_get_u16(group_tlvs[ROCKER_TLV_OF_DPA_VLAN_ID]); |
| } |
| |
| if (group_tlvs[ROCKER_TLV_OF_DPA_TTL_CHECK]) { |
| group->l3_unicast.ttl_check = |
| rocker_tlv_get_u8(group_tlvs[ROCKER_TLV_OF_DPA_TTL_CHECK]); |
| } |
| |
| return ROCKER_OK; |
| } |
| |
| static int of_dpa_cmd_group_do(OfDpa *of_dpa, uint32_t group_id, |
| OfDpaGroup *group, RockerTlv **group_tlvs) |
| { |
| uint8_t type = ROCKER_GROUP_TYPE_GET(group_id); |
| |
| switch (type) { |
| case ROCKER_OF_DPA_GROUP_TYPE_L2_INTERFACE: |
| return of_dpa_cmd_add_l2_interface(group, group_tlvs); |
| case ROCKER_OF_DPA_GROUP_TYPE_L2_REWRITE: |
| return of_dpa_cmd_add_l2_rewrite(of_dpa, group, group_tlvs); |
| case ROCKER_OF_DPA_GROUP_TYPE_L2_FLOOD: |
| /* Treat L2 multicast group same as a L2 flood group */ |
| case ROCKER_OF_DPA_GROUP_TYPE_L2_MCAST: |
| return of_dpa_cmd_add_l2_flood(of_dpa, group, group_tlvs); |
| case ROCKER_OF_DPA_GROUP_TYPE_L3_UCAST: |
| return of_dpa_cmd_add_l3_unicast(group, group_tlvs); |
| } |
| |
| return -ROCKER_ENOTSUP; |
| } |
| |
| static int of_dpa_cmd_group_add(OfDpa *of_dpa, uint32_t group_id, |
| RockerTlv **group_tlvs) |
| { |
| OfDpaGroup *group = of_dpa_group_find(of_dpa, group_id); |
| int err; |
| |
| if (group) { |
| return -ROCKER_EEXIST; |
| } |
| |
| group = of_dpa_group_alloc(group_id); |
| if (!group) { |
| return -ROCKER_ENOMEM; |
| } |
| |
| err = of_dpa_cmd_group_do(of_dpa, group_id, group, group_tlvs); |
| if (err) { |
| goto err_cmd_add; |
| } |
| |
| err = of_dpa_group_add(of_dpa, group); |
| if (err) { |
| goto err_cmd_add; |
| } |
| |
| return ROCKER_OK; |
| |
| err_cmd_add: |
| g_free(group); |
| return err; |
| } |
| |
| static int of_dpa_cmd_group_mod(OfDpa *of_dpa, uint32_t group_id, |
| RockerTlv **group_tlvs) |
| { |
| OfDpaGroup *group = of_dpa_group_find(of_dpa, group_id); |
| |
| if (!group) { |
| return -ROCKER_ENOENT; |
| } |
| |
| return of_dpa_cmd_group_do(of_dpa, group_id, group, group_tlvs); |
| } |
| |
| static int of_dpa_cmd_group_del(OfDpa *of_dpa, uint32_t group_id) |
| { |
| OfDpaGroup *group = of_dpa_group_find(of_dpa, group_id); |
| |
| if (!group) { |
| return -ROCKER_ENOENT; |
| } |
| |
| return of_dpa_group_del(of_dpa, group); |
| } |
| |
| static int of_dpa_cmd_group_get_stats(OfDpa *of_dpa, uint32_t group_id, |
| struct desc_info *info, char *buf) |
| { |
| return -ROCKER_ENOTSUP; |
| } |
| |
| static int of_dpa_group_cmd(OfDpa *of_dpa, struct desc_info *info, |
| char *buf, uint16_t cmd, RockerTlv **group_tlvs) |
| { |
| uint32_t group_id; |
| |
| if (!group_tlvs[ROCKER_TLV_OF_DPA_GROUP_ID]) { |
| return -ROCKER_EINVAL; |
| } |
| |
| group_id = rocker_tlv_get_le32(group_tlvs[ROCKER_TLV_OF_DPA_GROUP_ID]); |
| |
| switch (cmd) { |
| case ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_ADD: |
| return of_dpa_cmd_group_add(of_dpa, group_id, group_tlvs); |
| case ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_MOD: |
| return of_dpa_cmd_group_mod(of_dpa, group_id, group_tlvs); |
| case ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_DEL: |
| return of_dpa_cmd_group_del(of_dpa, group_id); |
| case ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_GET_STATS: |
| return of_dpa_cmd_group_get_stats(of_dpa, group_id, info, buf); |
| } |
| |
| return -ROCKER_ENOTSUP; |
| } |
| |
| static int of_dpa_cmd(World *world, struct desc_info *info, |
| char *buf, uint16_t cmd, RockerTlv *cmd_info_tlv) |
| { |
| OfDpa *of_dpa = world_private(world); |
| RockerTlv *tlvs[ROCKER_TLV_OF_DPA_MAX + 1]; |
| |
| rocker_tlv_parse_nested(tlvs, ROCKER_TLV_OF_DPA_MAX, cmd_info_tlv); |
| |
| switch (cmd) { |
| case ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_ADD: |
| case ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_MOD: |
| case ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_DEL: |
| case ROCKER_TLV_CMD_TYPE_OF_DPA_FLOW_GET_STATS: |
| return of_dpa_flow_cmd(of_dpa, info, buf, cmd, tlvs); |
| case ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_ADD: |
| case ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_MOD: |
| case ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_DEL: |
| case ROCKER_TLV_CMD_TYPE_OF_DPA_GROUP_GET_STATS: |
| return of_dpa_group_cmd(of_dpa, info, buf, cmd, tlvs); |
| } |
| |
| return -ROCKER_ENOTSUP; |
| } |
| |
| static gboolean rocker_int64_equal(gconstpointer v1, gconstpointer v2) |
| { |
| return *((const uint64_t *)v1) == *((const uint64_t *)v2); |
| } |
| |
| static guint rocker_int64_hash(gconstpointer v) |
| { |
| return (guint)*(const uint64_t *)v; |
| } |
| |
| static int of_dpa_init(World *world) |
| { |
| OfDpa *of_dpa = world_private(world); |
| |
| of_dpa->world = world; |
| |
| of_dpa->flow_tbl = g_hash_table_new_full(rocker_int64_hash, |
| rocker_int64_equal, |
| NULL, g_free); |
| if (!of_dpa->flow_tbl) { |
| return -ENOMEM; |
| } |
| |
| of_dpa->group_tbl = g_hash_table_new_full(g_int_hash, g_int_equal, |
| NULL, g_free); |
| if (!of_dpa->group_tbl) { |
| goto err_group_tbl; |
| } |
| |
| /* XXX hardcode some artificial table max values */ |
| of_dpa->flow_tbl_max_size = 100; |
| of_dpa->group_tbl_max_size = 100; |
| |
| return 0; |
| |
| err_group_tbl: |
| g_hash_table_destroy(of_dpa->flow_tbl); |
| return -ENOMEM; |
| } |
| |
| static void of_dpa_uninit(World *world) |
| { |
| OfDpa *of_dpa = world_private(world); |
| |
| g_hash_table_destroy(of_dpa->group_tbl); |
| g_hash_table_destroy(of_dpa->flow_tbl); |
| } |
| |
| struct of_dpa_flow_fill_context { |
| RockerOfDpaFlowList *list; |
| uint32_t tbl_id; |
| }; |
| |
| static void of_dpa_flow_fill(void *cookie, void *value, void *user_data) |
| { |
| struct of_dpa_flow *flow = value; |
| struct of_dpa_flow_key *key = &flow->key; |
| struct of_dpa_flow_key *mask = &flow->mask; |
| struct of_dpa_flow_fill_context *flow_context = user_data; |
| RockerOfDpaFlowList *new; |
| RockerOfDpaFlow *nflow; |
| RockerOfDpaFlowKey *nkey; |
| RockerOfDpaFlowMask *nmask; |
| RockerOfDpaFlowAction *naction; |
| |
| if (flow_context->tbl_id != -1 && |
| flow_context->tbl_id != key->tbl_id) { |
| return; |
| } |
| |
| new = g_malloc0(sizeof(*new)); |
| nflow = new->value = g_malloc0(sizeof(*nflow)); |
| nkey = nflow->key = g_malloc0(sizeof(*nkey)); |
| nmask = nflow->mask = g_malloc0(sizeof(*nmask)); |
| naction = nflow->action = g_malloc0(sizeof(*naction)); |
| |
| nflow->cookie = flow->cookie; |
| nflow->hits = flow->stats.hits; |
| nkey->priority = flow->priority; |
| nkey->tbl_id = key->tbl_id; |
| |
| if (key->in_pport || mask->in_pport) { |
| nkey->has_in_pport = true; |
| nkey->in_pport = key->in_pport; |
| } |
| |
| if (nkey->has_in_pport && mask->in_pport != 0xffffffff) { |
| nmask->has_in_pport = true; |
| nmask->in_pport = mask->in_pport; |
| } |
| |
| if (key->eth.vlan_id || mask->eth.vlan_id) { |
| nkey->has_vlan_id = true; |
| nkey->vlan_id = ntohs(key->eth.vlan_id); |
| } |
| |
| if (nkey->has_vlan_id && mask->eth.vlan_id != 0xffff) { |
| nmask->has_vlan_id = true; |
| nmask->vlan_id = ntohs(mask->eth.vlan_id); |
| } |
| |
| if (key->tunnel_id || mask->tunnel_id) { |
| nkey->has_tunnel_id = true; |
| nkey->tunnel_id = key->tunnel_id; |
| } |
| |
| if (nkey->has_tunnel_id && mask->tunnel_id != 0xffffffff) { |
| nmask->has_tunnel_id = true; |
| nmask->tunnel_id = mask->tunnel_id; |
| } |
| |
| if (memcmp(key->eth.src.a, zero_mac.a, ETH_ALEN) || |
| memcmp(mask->eth.src.a, zero_mac.a, ETH_ALEN)) { |
| nkey->has_eth_src = true; |
| nkey->eth_src = qemu_mac_strdup_printf(key->eth.src.a); |
| } |
| |
| if (nkey->has_eth_src && memcmp(mask->eth.src.a, ff_mac.a, ETH_ALEN)) { |
| nmask->has_eth_src = true; |
| nmask->eth_src = qemu_mac_strdup_printf(mask->eth.src.a); |
| } |
| |
| if (memcmp(key->eth.dst.a, zero_mac.a, ETH_ALEN) || |
| memcmp(mask->eth.dst.a, zero_mac.a, ETH_ALEN)) { |
| nkey->has_eth_dst = true; |
| nkey->eth_dst = qemu_mac_strdup_printf(key->eth.dst.a); |
| } |
| |
| if (nkey->has_eth_dst && memcmp(mask->eth.dst.a, ff_mac.a, ETH_ALEN)) { |
| nmask->has_eth_dst = true; |
| nmask->eth_dst = qemu_mac_strdup_printf(mask->eth.dst.a); |
| } |
| |
| if (key->eth.type) { |
| |
| nkey->has_eth_type = true; |
| nkey->eth_type = ntohs(key->eth.type); |
| |
| switch (ntohs(key->eth.type)) { |
| case 0x0800: |
| case 0x86dd: |
| if (key->ip.proto || mask->ip.proto) { |
| nkey->has_ip_proto = true; |
| nkey->ip_proto = key->ip.proto; |
| } |
| if (nkey->has_ip_proto && mask->ip.proto != 0xff) { |
| nmask->has_ip_proto = true; |
| nmask->ip_proto = mask->ip.proto; |
| } |
| if (key->ip.tos || mask->ip.tos) { |
| nkey->has_ip_tos = true; |
| nkey->ip_tos = key->ip.tos; |
| } |
| if (nkey->has_ip_tos && mask->ip.tos != 0xff) { |
| nmask->has_ip_tos = true; |
| nmask->ip_tos = mask->ip.tos; |
| } |
| break; |
| } |
| |
| switch (ntohs(key->eth.type)) { |
| case 0x0800: |
| if (key->ipv4.addr.dst || mask->ipv4.addr.dst) { |
| char *dst = inet_ntoa(*(struct in_addr *)&key->ipv4.addr.dst); |
| int dst_len = of_dpa_mask2prefix(mask->ipv4.addr.dst); |
| nkey->has_ip_dst = true; |
| nkey->ip_dst = g_strdup_printf("%s/%d", dst, dst_len); |
| } |
| break; |
| } |
| } |
| |
| if (flow->action.goto_tbl) { |
| naction->has_goto_tbl = true; |
| naction->goto_tbl = flow->action.goto_tbl; |
| } |
| |
| if (flow->action.write.group_id) { |
| naction->has_group_id = true; |
| naction->group_id = flow->action.write.group_id; |
| } |
| |
| if (flow->action.apply.new_vlan_id) { |
| naction->has_new_vlan_id = true; |
| naction->new_vlan_id = flow->action.apply.new_vlan_id; |
| } |
| |
| new->next = flow_context->list; |
| flow_context->list = new; |
| } |
| |
| RockerOfDpaFlowList *qmp_query_rocker_of_dpa_flows(const char *name, |
| bool has_tbl_id, |
| uint32_t tbl_id, |
| Error **errp) |
| { |
| struct rocker *r; |
| struct world *w; |
| struct of_dpa *of_dpa; |
| struct of_dpa_flow_fill_context fill_context = { |
| .list = NULL, |
| .tbl_id = tbl_id, |
| }; |
| |
| r = rocker_find(name); |
| if (!r) { |
| error_setg(errp, "rocker %s not found", name); |
| return NULL; |
| } |
| |
| w = rocker_get_world(r, ROCKER_WORLD_TYPE_OF_DPA); |
| if (!w) { |
| error_setg(errp, "rocker %s doesn't have OF-DPA world", name); |
| return NULL; |
| } |
| |
| of_dpa = world_private(w); |
| |
| g_hash_table_foreach(of_dpa->flow_tbl, of_dpa_flow_fill, &fill_context); |
| |
| return fill_context.list; |
| } |
| |
| struct of_dpa_group_fill_context { |
| RockerOfDpaGroupList *list; |
| uint8_t type; |
| }; |
| |
| static void of_dpa_group_fill(void *key, void *value, void *user_data) |
| { |
| struct of_dpa_group *group = value; |
| struct of_dpa_group_fill_context *flow_context = user_data; |
| RockerOfDpaGroupList *new; |
| RockerOfDpaGroup *ngroup; |
| struct uint32List *id; |
| int i; |
| |
| if (flow_context->type != 9 && |
| flow_context->type != ROCKER_GROUP_TYPE_GET(group->id)) { |
| return; |
| } |
| |
| new = g_malloc0(sizeof(*new)); |
| ngroup = new->value = g_malloc0(sizeof(*ngroup)); |
| |
| ngroup->id = group->id; |
| |
| ngroup->type = ROCKER_GROUP_TYPE_GET(group->id); |
| |
| switch (ngroup->type) { |
| case ROCKER_OF_DPA_GROUP_TYPE_L2_INTERFACE: |
| ngroup->has_vlan_id = true; |
| ngroup->vlan_id = ROCKER_GROUP_VLAN_GET(group->id); |
| ngroup->has_pport = true; |
| ngroup->pport = ROCKER_GROUP_PORT_GET(group->id); |
| ngroup->has_out_pport = true; |
| ngroup->out_pport = group->l2_interface.out_pport; |
| ngroup->has_pop_vlan = true; |
| ngroup->pop_vlan = group->l2_interface.pop_vlan; |
| break; |
| case ROCKER_OF_DPA_GROUP_TYPE_L2_REWRITE: |
| ngroup->has_index = true; |
| ngroup->index = ROCKER_GROUP_INDEX_LONG_GET(group->id); |
| ngroup->has_group_id = true; |
| ngroup->group_id = group->l2_rewrite.group_id; |
| if (group->l2_rewrite.vlan_id) { |
| ngroup->has_set_vlan_id = true; |
| ngroup->set_vlan_id = ntohs(group->l2_rewrite.vlan_id); |
| } |
| if (memcmp(group->l2_rewrite.src_mac.a, zero_mac.a, ETH_ALEN)) { |
| ngroup->has_set_eth_src = true; |
| ngroup->set_eth_src = |
| qemu_mac_strdup_printf(group->l2_rewrite.src_mac.a); |
| } |
| if (memcmp(group->l2_rewrite.dst_mac.a, zero_mac.a, ETH_ALEN)) { |
| ngroup->has_set_eth_dst = true; |
| ngroup->set_eth_dst = |
| qemu_mac_strdup_printf(group->l2_rewrite.dst_mac.a); |
| } |
| break; |
| case ROCKER_OF_DPA_GROUP_TYPE_L2_FLOOD: |
| case ROCKER_OF_DPA_GROUP_TYPE_L2_MCAST: |
| ngroup->has_vlan_id = true; |
| ngroup->vlan_id = ROCKER_GROUP_VLAN_GET(group->id); |
| ngroup->has_index = true; |
| ngroup->index = ROCKER_GROUP_INDEX_GET(group->id); |
| for (i = 0; i < group->l2_flood.group_count; i++) { |
| ngroup->has_group_ids = true; |
| id = g_malloc0(sizeof(*id)); |
| id->value = group->l2_flood.group_ids[i]; |
| id->next = ngroup->group_ids; |
| ngroup->group_ids = id; |
| } |
| break; |
| case ROCKER_OF_DPA_GROUP_TYPE_L3_UCAST: |
| ngroup->has_index = true; |
| ngroup->index = ROCKER_GROUP_INDEX_LONG_GET(group->id); |
| ngroup->has_group_id = true; |
| ngroup->group_id = group->l3_unicast.group_id; |
| if (group->l3_unicast.vlan_id) { |
| ngroup->has_set_vlan_id = true; |
| ngroup->set_vlan_id = ntohs(group->l3_unicast.vlan_id); |
| } |
| if (memcmp(group->l3_unicast.src_mac.a, zero_mac.a, ETH_ALEN)) { |
| ngroup->has_set_eth_src = true; |
| ngroup->set_eth_src = |
| qemu_mac_strdup_printf(group->l3_unicast.src_mac.a); |
| } |
| if (memcmp(group->l3_unicast.dst_mac.a, zero_mac.a, ETH_ALEN)) { |
| ngroup->has_set_eth_dst = true; |
| ngroup->set_eth_dst = |
| qemu_mac_strdup_printf(group->l3_unicast.dst_mac.a); |
| } |
| if (group->l3_unicast.ttl_check) { |
| ngroup->has_ttl_check = true; |
| ngroup->ttl_check = group->l3_unicast.ttl_check; |
| } |
| break; |
| } |
| |
| new->next = flow_context->list; |
| flow_context->list = new; |
| } |
| |
| RockerOfDpaGroupList *qmp_query_rocker_of_dpa_groups(const char *name, |
| bool has_type, |
| uint8_t type, |
| Error **errp) |
| { |
| struct rocker *r; |
| struct world *w; |
| struct of_dpa *of_dpa; |
| struct of_dpa_group_fill_context fill_context = { |
| .list = NULL, |
| .type = type, |
| }; |
| |
| r = rocker_find(name); |
| if (!r) { |
| error_setg(errp, "rocker %s not found", name); |
| return NULL; |
| } |
| |
| w = rocker_get_world(r, ROCKER_WORLD_TYPE_OF_DPA); |
| if (!w) { |
| error_setg(errp, "rocker %s doesn't have OF-DPA world", name); |
| return NULL; |
| } |
| |
| of_dpa = world_private(w); |
| |
| g_hash_table_foreach(of_dpa->group_tbl, of_dpa_group_fill, &fill_context); |
| |
| return fill_context.list; |
| } |
| |
| static WorldOps of_dpa_ops = { |
| .name = "ofdpa", |
| .init = of_dpa_init, |
| .uninit = of_dpa_uninit, |
| .ig = of_dpa_ig, |
| .cmd = of_dpa_cmd, |
| }; |
| |
| World *of_dpa_world_alloc(Rocker *r) |
| { |
| return world_alloc(r, sizeof(OfDpa), ROCKER_WORLD_TYPE_OF_DPA, &of_dpa_ops); |
| } |
