VNFs/DPPD-PROX/packet_utils.c

   1 /*
   2 // Copyright (c) 2010-2020 Intel Corporation
   3 //
   4 // Licensed under the Apache License, Version 2.0 (the "License");
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //     http://www.apache.org/licenses/LICENSE-2.0
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an "AS IS" BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 */
  16
  17 #include <rte_lcore.h>
  18 #include <rte_hash.h>
  19 #include <rte_hash_crc.h>
  20 #include "task_base.h"
  21 #include "lconf.h"
  22 #include "prefetch.h"
  23 #include "log.h"
  24 #include "defines.h"
  25 #include "handle_master.h"
  26 #include "prox_port_cfg.h"
  27
  28 static inline int find_ip(struct ether_hdr_arp *pkt, uint16_t len, uint32_t *ip_dst)
  29 {
  30         prox_rte_vlan_hdr *vlan_hdr;
  31         prox_rte_ether_hdr *eth_hdr = (prox_rte_ether_hdr*)pkt;
  32         prox_rte_ipv4_hdr *ip;
  33         uint16_t ether_type = eth_hdr->ether_type;
  34         uint16_t l2_len = sizeof(prox_rte_ether_hdr);
  35
  36         // Unstack VLAN tags
  37         while (((ether_type == ETYPE_8021ad) || (ether_type == ETYPE_VLAN)) && (l2_len + sizeof(prox_rte_vlan_hdr) < len)) {
  38                 vlan_hdr = (prox_rte_vlan_hdr *)((uint8_t *)pkt + l2_len);
  39                 l2_len +=4;
  40                 ether_type = vlan_hdr->eth_proto;
  41         }
  42
  43         switch (ether_type) {
  44         case ETYPE_MPLSU:
  45         case ETYPE_MPLSM:
  46                 // In case of MPLS, next hop MAC is based on MPLS, not destination IP
  47                 l2_len = 0;
  48                 break;
  49         case ETYPE_IPv4:
  50                 break;
  51         case ETYPE_EoGRE:
  52         case ETYPE_ARP:
  53         case ETYPE_IPv6:
  54                 l2_len = 0;
  55                 break;
  56         default:
  57                 l2_len = 0;
  58                 plog_warn("Unsupported packet type %x - CRC might be wrong\n", ether_type);
  59                 break;
  60         }
  61
  62         if (l2_len && (l2_len + sizeof(prox_rte_ipv4_hdr) <= len)) {
  63                 prox_rte_ipv4_hdr *ip = (prox_rte_ipv4_hdr *)((uint8_t *)pkt + l2_len);
  64                 // TODO: implement LPM => replace ip_dst by next hop IP DST
  65                 *ip_dst = ip->dst_addr;
  66                 return 0;
  67         }
  68         return -1;
  69 }
  70
  71 /* This implementation could be improved: instead of checking each time we send a packet whether we need also
  72    to send an ARP, we should only check whether the MAC is valid.
  73    We should check arp_update_time in the master process. This would also require the generating task to clear its arp ring
  74    to avoid sending many ARP while starting after a long stop.
  75    We could also check for arp_timeout in the master so that dataplane has only to check whether MAC is available
  76    but this would require either thread safety, or the the exchange of information between master and generating core.
  77 */
  78
  79 int write_dst_mac(struct task_base *tbase, struct rte_mbuf *mbuf, uint32_t *ip_dst)
  80 {
  81         const uint64_t hz = rte_get_tsc_hz();
  82         struct ether_hdr_arp *packet = rte_pktmbuf_mtod(mbuf, struct ether_hdr_arp *);
  83         prox_rte_ether_addr *mac = &packet->ether_hdr.d_addr;
  84
  85         uint64_t tsc = rte_rdtsc();
  86         struct l3_base *l3 = &(tbase->l3);
  87         if (l3->gw.ip) {
  88                 if (likely((l3->flags & FLAG_DST_MAC_KNOWN) && (tsc < l3->gw.arp_update_time) && (tsc < l3->gw.arp_timeout))) {
  89                         memcpy(mac, &l3->gw.mac, sizeof(prox_rte_ether_addr));
  90                         return SEND_MBUF;
  91                 } else if (tsc > l3->gw.arp_update_time) {
  92                         // long time since we have sent an arp, send arp
  93                         l3->gw.arp_update_time = tsc + l3->arp_update_time * hz / 1000;
  94                         *ip_dst = l3->gw.ip;
  95                         if ((l3->flags & FLAG_DST_MAC_KNOWN) && (tsc < l3->gw.arp_timeout)){
  96                                 // MAC is valid in the table => send also the mbuf
  97                                 memcpy(mac, &l3->gw.mac, sizeof(prox_rte_ether_addr));
  98                                 return SEND_MBUF_AND_ARP;
  99                         } else {
 100                                 // MAC still unknown, or timed out => only send ARP
 101                                 return SEND_ARP;
 102                         }
 103                 } else {
 104                         // MAC is unknown and we already sent an ARP recently, drop mbuf and wait for ARP reply
 105                         return DROP_MBUF;
 106                 }
 107         }
 108
 109         uint16_t len = rte_pktmbuf_pkt_len(mbuf);
 110         if (find_ip(packet, len, ip_dst) != 0) {
 111                 // Unable to find IP address => non IP packet => send it as it
 112                 return SEND_MBUF;
 113         }
 114         if (likely(l3->n_pkts < 4)) {
 115                 for (unsigned int idx = 0; idx < l3->n_pkts; idx++) {
 116                         if (*ip_dst == l3->optimized_arp_table[idx].ip) {
 117                                  // IP address already in table
 118                                 if ((tsc < l3->optimized_arp_table[idx].arp_update_time) && (tsc < l3->optimized_arp_table[idx].arp_timeout)) {
 119                                         // MAC address was recently updated in table, use it
 120                                         memcpy(mac, &l3->optimized_arp_table[idx].mac, sizeof(prox_rte_ether_addr));
 121                                         return SEND_MBUF;
 122                                 } else if (tsc > l3->optimized_arp_table[idx].arp_update_time) {
 123                                         // ARP not sent since a long time, send ARP
 124                                         l3->optimized_arp_table[idx].arp_update_time = tsc + l3->arp_update_time * hz / 1000;
 125                                         if (tsc < l3->optimized_arp_table[idx].arp_timeout) {
 126                                                 // MAC still valid => also send mbuf
 127                                                 memcpy(mac, &l3->optimized_arp_table[idx].mac, sizeof(prox_rte_ether_addr));
 128                                                 return SEND_MBUF_AND_ARP;
 129                                         } else {
 130                                                 // MAC unvalid => only send ARP
 131                                                 return SEND_ARP;
 132                                         }
 133                                 } else {
 134                                         //  ARP timeout elapsed, MAC not valid anymore but waiting for ARP reply
 135                                         return DROP_MBUF;
 136                                 }
 137                         }
 138                 }
 139                 // IP address not found in table
 140                 l3->optimized_arp_table[l3->n_pkts].ip = *ip_dst;
 141                 l3->optimized_arp_table[l3->n_pkts].arp_update_time = tsc + l3->arp_update_time * hz / 1000;
 142                 l3->n_pkts++;
 143
 144                 if (l3->n_pkts < 4) {
 145                         return SEND_ARP;
 146                 }
 147
 148                 // We have too many IP addresses to search linearly; lets use hash table instead => copy all entries in hash table
 149                 for (uint32_t idx = 0; idx < l3->n_pkts; idx++) {
 150                         uint32_t ip = l3->optimized_arp_table[idx].ip;
 151                         int ret = rte_hash_add_key(l3->ip_hash, (const void *)&ip);
 152                         if (ret < 0) {
 153                                 // This should not happen as few entries so far.
 154                                 // If it happens, we still send the ARP as easier:
 155                                 //      If the ARP corresponds to this error, the ARP reply will be ignored
 156                                 //      If ARP does not correspond to this error/ip, then ARP reply will be handled.
 157                                 plogx_err("Unable add ip %d.%d.%d.%d in mac_hash (already %d entries)\n", IP4(ip), idx);
 158                         } else {
 159                                 memcpy(&l3->arp_table[ret], &l3->optimized_arp_table[idx], sizeof(struct arp_table));
 160                         }
 161                 }
 162                 return SEND_ARP;
 163         } else {
 164                 // Find IP in lookup table. Send ARP if not found
 165                 int ret = rte_hash_lookup(l3->ip_hash, (const void *)ip_dst);
 166                 if (unlikely(ret < 0)) {
 167                         // IP not found, try to send an ARP
 168                         int ret = rte_hash_add_key(l3->ip_hash, (const void *)ip_dst);
 169                         if (ret < 0) {
 170                                 // No reason to send ARP, as reply would be anyhow ignored
 171                                 plogx_err("Unable to add ip %d.%d.%d.%d in mac_hash\n", IP4(*ip_dst));
 172                                 return DROP_MBUF;
 173                         } else {
 174                                 l3->arp_table[ret].ip = *ip_dst;
 175                                 l3->arp_table[ret].arp_update_time = tsc + l3->arp_update_time * hz / 1000;
 176                         }
 177                         return SEND_ARP;
 178                 } else {
 179                         // IP has been found
 180                         if (likely((tsc < l3->arp_table[ret].arp_update_time) && (tsc < l3->arp_table[ret].arp_timeout))) {
 181                                 // MAC still valid and ARP sent recently
 182                                 memcpy(mac, &l3->arp_table[ret].mac, sizeof(prox_rte_ether_addr));
 183                                 return SEND_MBUF;
 184                         } else if (tsc > l3->arp_table[ret].arp_update_time) {
 185                                 // ARP not sent since a long time, send ARP
 186                                 l3->arp_table[ret].arp_update_time = tsc + l3->arp_update_time * hz / 1000;
 187                                 if (tsc < l3->arp_table[ret].arp_timeout) {
 188                                         // MAC still valid => send also MBUF
 189                                         memcpy(mac, &l3->arp_table[ret].mac, sizeof(prox_rte_ether_addr));
 190                                         return SEND_MBUF_AND_ARP;
 191                                 } else {
 192                                         return SEND_ARP;
 193                                 }
 194                         } else {
 195                                 return DROP_MBUF;
 196                         }
 197                 }
 198         }
 199         // Should not happen
 200         return DROP_MBUF;
 201 }
 202
 203 void task_init_l3(struct task_base *tbase, struct task_args *targ)
 204 {
 205         static char hash_name[30];
 206         uint32_t n_entries = MAX_ARP_ENTRIES * 4;
 207         const int socket_id = rte_lcore_to_socket_id(targ->lconf->id);
 208         sprintf(hash_name, "A%03d_%03d_mac_table", targ->lconf->id, targ->id);
 209
 210         hash_name[0]++;
 211
 212         struct rte_hash_parameters hash_params = {
 213                 .name = hash_name,
 214                 .entries = n_entries,
 215                 .key_len = sizeof(uint32_t),
 216                 .hash_func = rte_hash_crc,
 217                 .hash_func_init_val = 0,
 218         };
 219         tbase->l3.ip_hash = rte_hash_create(&hash_params);
 220         PROX_PANIC(tbase->l3.ip_hash == NULL, "Failed to set up ip hash table\n");
 221
 222         tbase->l3.arp_table = (struct arp_table *)prox_zmalloc(n_entries * sizeof(struct arp_table), socket_id);
 223         PROX_PANIC(tbase->l3.arp_table == NULL, "Failed to allocate memory for %u entries in arp table\n", n_entries);
 224         plog_info("\tarp table, with %d entries of size %ld\n", n_entries, sizeof(struct l3_base));
 225
 226         targ->lconf->ctrl_func_p[targ->task] = handle_ctrl_plane_pkts;
 227         targ->lconf->ctrl_timeout = freq_to_tsc(targ->ctrl_freq);
 228         tbase->l3.gw.ip = rte_cpu_to_be_32(targ->gateway_ipv4);
 229         tbase->flags |= TASK_L3;
 230         tbase->l3.core_id = targ->lconf->id;
 231         tbase->l3.task_id = targ->id;
 232         tbase->l3.tmaster = targ->tmaster;
 233         if (targ->arp_timeout != 0)
 234                 tbase->l3.arp_timeout = targ->arp_timeout;
 235         else
 236                 tbase->l3.arp_timeout = DEFAULT_ARP_TIMEOUT;
 237         if (targ->arp_update_time != 0)
 238                 tbase->l3.arp_update_time = targ->arp_update_time;
 239         else
 240                 tbase->l3.arp_update_time = DEFAULT_ARP_UPDATE_TIME;
 241 }
 242
 243 void task_start_l3(struct task_base *tbase, struct task_args *targ)
 244 {
 245         const int NB_ARP_MBUF = 1024;
 246         const int ARP_MBUF_SIZE = 2048;
 247         const int NB_CACHE_ARP_MBUF = 256;
 248
 249         struct prox_port_cfg *port = find_reachable_port(targ);
 250         if (port && (tbase->l3.arp_pool == NULL)) {
 251                 static char name[] = "arp0_pool";
 252                 tbase->l3.reachable_port_id = port - prox_port_cfg;
 253                 if (targ->local_ipv4) {
 254                         tbase->local_ipv4 = rte_be_to_cpu_32(targ->local_ipv4);
 255                         register_ip_to_ctrl_plane(tbase->l3.tmaster, tbase->local_ipv4, tbase->l3.reachable_port_id, targ->lconf->id, targ->id);
 256                 }
 257                 master_init_vdev(tbase->l3.tmaster, tbase->l3.reachable_port_id, targ->lconf->id, targ->id);
 258                 name[3]++;
 259                 struct rte_mempool *ret = rte_mempool_create(name, NB_ARP_MBUF, ARP_MBUF_SIZE, NB_CACHE_ARP_MBUF,
 260                         sizeof(struct rte_pktmbuf_pool_private), rte_pktmbuf_pool_init, NULL, rte_pktmbuf_init, 0,
 261                         rte_socket_id(), 0);
 262                 PROX_PANIC(ret == NULL, "Failed to allocate ARP memory pool on socket %u with %u elements\n",
 263                         rte_socket_id(), NB_ARP_MBUF);
 264                 plog_info("\t\tMempool %p (%s) size = %u * %u cache %u, socket %d\n", ret, name, NB_ARP_MBUF,
 265                         ARP_MBUF_SIZE, NB_CACHE_ARP_MBUF, rte_socket_id());
 266                 tbase->l3.arp_pool = ret;
 267         }
 268 }
 269
 270 void task_set_gateway_ip(struct task_base *tbase, uint32_t ip)
 271 {
 272         tbase->l3.gw.ip = ip;
 273         tbase->flags &= ~FLAG_DST_MAC_KNOWN;
 274 }
 275
 276 void task_set_local_ip(struct task_base *tbase, uint32_t ip)
 277 {
 278         tbase->local_ipv4 = ip;
 279 }
 280
 281 static void reset_arp_update_time(struct l3_base *l3, uint32_t ip)
 282 {
 283         uint32_t idx;
 284         plogx_info("\tMAC entry for IP "IPv4_BYTES_FMT" timeout in kernel\n", IP4(ip));
 285         if (ip == l3->gw.ip) {
 286                 l3->gw.arp_update_time = 0;
 287         } else if (l3->n_pkts < 4) {
 288                 for (idx = 0; idx < l3->n_pkts; idx++) {
 289                         uint32_t ip_dst = l3->optimized_arp_table[idx].ip;
 290                         if (ip_dst == ip)
 291                                 break;
 292                 }
 293                 if (idx < l3->n_pkts) {
 294                         l3->optimized_arp_table[idx].arp_update_time = 0;
 295                 }
 296         } else {
 297                 int ret = rte_hash_lookup(l3->ip_hash, (const void *)&ip);
 298                 if (ret >= 0)
 299                         l3->arp_table[ret].arp_update_time = 0;
 300         }
 301         return;
 302 }
 303
 304 void handle_ctrl_plane_pkts(struct task_base *tbase, struct rte_mbuf **mbufs, uint16_t n_pkts)
 305 {
 306         uint8_t out[1];
 307         const uint64_t hz = rte_get_tsc_hz();
 308         uint32_t ip, ip_dst, idx;
 309         int j;
 310         uint16_t command;
 311         struct ether_hdr_arp *hdr;
 312         struct l3_base *l3 = &tbase->l3;
 313         uint64_t tsc= rte_rdtsc();
 314         uint64_t update_time = l3->arp_timeout * hz / 1000;
 315
 316         for (j = 0; j < n_pkts; ++j) {
 317                 PREFETCH0(mbufs[j]);
 318         }
 319         for (j = 0; j < n_pkts; ++j) {
 320                 PREFETCH0(rte_pktmbuf_mtod(mbufs[j], void *));
 321         }
 322
 323         for (j = 0; j < n_pkts; ++j) {
 324                 out[0] = OUT_HANDLED;
 325                 command = mbufs[j]->udata64 & 0xFFFF;
 326                 plogx_dbg("\tReceived %s mbuf %p\n", actions_string[command], mbufs[j]);
 327                 switch(command) {
 328                 case UPDATE_FROM_CTRL:
 329                         hdr = rte_pktmbuf_mtod(mbufs[j], struct ether_hdr_arp *);
 330                         ip = (mbufs[j]->udata64 >> 32) & 0xFFFFFFFF;
 331
 332                         if (prox_rte_is_zero_ether_addr(&hdr->arp.data.sha)) {
 333                                 // MAC timeout or deleted from kernel table => reset update_time
 334                                 // This will cause us to send new ARP request
 335                                 // However, as arp_timeout not touched, we should continue sending our regular IP packets
 336                                 reset_arp_update_time(l3, ip);
 337                                 plogx_info("\tTimeout for MAC entry for IP "IPv4_BYTES_FMT"\n", IP4(ip));
 338                                 return;
 339                         } else
 340                                 plogx_dbg("\tUpdating MAC entry for IP "IPv4_BYTES_FMT" with MAC "MAC_BYTES_FMT"\n",
 341                                         IP4(ip), MAC_BYTES(hdr->arp.data.sha.addr_bytes));
 342                         if (ip == l3->gw.ip) {
 343                                 // MAC address of the gateway
 344                                 memcpy(&l3->gw.mac, &hdr->arp.data.sha, 6);
 345                                 l3->flags |= FLAG_DST_MAC_KNOWN;
 346                                 l3->gw.arp_timeout = tsc + update_time;
 347                         } else if (l3->n_pkts < 4) {
 348                                 // Few packets tracked - should be faster to loop through them thean using a hash table
 349                                 for (idx = 0; idx < l3->n_pkts; idx++) {
 350                                         ip_dst = l3->optimized_arp_table[idx].ip;
 351                                         if (ip_dst == ip)
 352                                                 break;
 353                                 }
 354                                 if (idx < l3->n_pkts) {
 355                                         memcpy(&l3->optimized_arp_table[idx].mac, &(hdr->arp.data.sha), sizeof(prox_rte_ether_addr));
 356                                         l3->optimized_arp_table[idx].arp_timeout = tsc + update_time;
 357                                 }
 358                         } else {
 359                                 int ret = rte_hash_add_key(l3->ip_hash, (const void *)&ip);
 360                                 if (ret < 0) {
 361                                         plogx_info("Unable add ip %d.%d.%d.%d in mac_hash\n", IP4(ip));
 362                                 } else {
 363                                         memcpy(&l3->arp_table[ret].mac, &(hdr->arp.data.sha), sizeof(prox_rte_ether_addr));
 364                                         l3->arp_table[ret].arp_timeout = tsc + update_time;
 365                                 }
 366                         }
 367                         tx_drop(mbufs[j]);
 368                         break;
 369                 case ARP_REPLY_FROM_CTRL:
 370                 case ICMP_FROM_CTRL:
 371                 case ARP_REQ_FROM_CTRL:
 372                 case PKT_FROM_TAP:
 373                         out[0] = 0;
 374                         // tx_ctrlplane_pkt does not drop packets
 375                         plogx_dbg("\tForwarding (ARP/PING) packet from master\n");
 376                         tbase->aux->tx_ctrlplane_pkt(tbase, &mbufs[j], 1, out);
 377                         TASK_STATS_ADD_TX_NON_DP(&tbase->aux->stats, 1);
 378                         break;
 379                 }
 380         }
 381 }