1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) 2 /* Copyright (C) 2017-2018 Netronome Systems, Inc. */ 3 4 #include <linux/etherdevice.h> 5 #include <linux/inetdevice.h> 6 #include <net/netevent.h> 7 #include <linux/idr.h> 8 #include <net/dst_metadata.h> 9 #include <net/arp.h> 10 11 #include "cmsg.h" 12 #include "main.h" 13 #include "../nfp_net_repr.h" 14 #include "../nfp_net.h" 15 16 #define NFP_FL_MAX_ROUTES 32 17 18 #define NFP_TUN_PRE_TUN_RULE_LIMIT 32 19 #define NFP_TUN_PRE_TUN_RULE_DEL BIT(0) 20 #define NFP_TUN_PRE_TUN_IDX_BIT BIT(3) 21 #define NFP_TUN_PRE_TUN_IPV6_BIT BIT(7) 22 23 /** 24 * struct nfp_tun_pre_tun_rule - rule matched before decap 25 * @flags: options for the rule offset 26 * @port_idx: index of destination MAC address for the rule 27 * @vlan_tci: VLAN info associated with MAC 28 * @host_ctx_id: stats context of rule to update 29 */ 30 struct nfp_tun_pre_tun_rule { 31 __be32 flags; 32 __be16 port_idx; 33 __be16 vlan_tci; 34 __be32 host_ctx_id; 35 }; 36 37 /** 38 * struct nfp_tun_active_tuns - periodic message of active tunnels 39 * @seq: sequence number of the message 40 * @count: number of tunnels report in message 41 * @flags: options part of the request 42 * @tun_info.ipv4: dest IPv4 address of active route 43 * @tun_info.egress_port: port the encapsulated packet egressed 44 * @tun_info.extra: reserved for future use 45 * @tun_info: tunnels that have sent traffic in reported period 46 */ 47 struct nfp_tun_active_tuns { 48 __be32 seq; 49 __be32 count; 50 __be32 flags; 51 struct route_ip_info { 52 __be32 ipv4; 53 __be32 egress_port; 54 __be32 extra[2]; 55 } tun_info[]; 56 }; 57 58 /** 59 * struct nfp_tun_active_tuns_v6 - periodic message of active IPv6 tunnels 60 * @seq: sequence number of the message 61 * @count: number of tunnels report in message 62 * @flags: options part of the request 63 * @tun_info.ipv6: dest IPv6 address of active route 64 * @tun_info.egress_port: port the encapsulated packet egressed 65 * @tun_info.extra: reserved for future use 66 * @tun_info: tunnels that have sent traffic in reported period 67 */ 68 struct nfp_tun_active_tuns_v6 { 69 __be32 seq; 70 __be32 count; 71 __be32 flags; 72 struct route_ip_info_v6 { 73 struct in6_addr ipv6; 74 __be32 egress_port; 75 __be32 extra[2]; 76 } tun_info[]; 77 }; 78 79 /** 80 * struct nfp_tun_req_route_ipv4 - NFP requests a route/neighbour lookup 81 * @ingress_port: ingress port of packet that signalled request 82 * @ipv4_addr: destination ipv4 address for route 83 * @reserved: reserved for future use 84 */ 85 struct nfp_tun_req_route_ipv4 { 86 __be32 ingress_port; 87 __be32 ipv4_addr; 88 __be32 reserved[2]; 89 }; 90 91 /** 92 * struct nfp_tun_req_route_ipv6 - NFP requests an IPv6 route/neighbour lookup 93 * @ingress_port: ingress port of packet that signalled request 94 * @ipv6_addr: destination ipv6 address for route 95 */ 96 struct nfp_tun_req_route_ipv6 { 97 __be32 ingress_port; 98 struct in6_addr ipv6_addr; 99 }; 100 101 /** 102 * struct nfp_offloaded_route - routes that are offloaded to the NFP 103 * @list: list pointer 104 * @ip_add: destination of route - can be IPv4 or IPv6 105 */ 106 struct nfp_offloaded_route { 107 struct list_head list; 108 u8 ip_add[]; 109 }; 110 111 #define NFP_FL_IPV4_ADDRS_MAX 32 112 113 /** 114 * struct nfp_tun_ipv4_addr - set the IP address list on the NFP 115 * @count: number of IPs populated in the array 116 * @ipv4_addr: array of IPV4_ADDRS_MAX 32 bit IPv4 addresses 117 */ 118 struct nfp_tun_ipv4_addr { 119 __be32 count; 120 __be32 ipv4_addr[NFP_FL_IPV4_ADDRS_MAX]; 121 }; 122 123 /** 124 * struct nfp_ipv4_addr_entry - cached IPv4 addresses 125 * @ipv4_addr: IP address 126 * @ref_count: number of rules currently using this IP 127 * @list: list pointer 128 */ 129 struct nfp_ipv4_addr_entry { 130 __be32 ipv4_addr; 131 int ref_count; 132 struct list_head list; 133 }; 134 135 #define NFP_FL_IPV6_ADDRS_MAX 4 136 137 /** 138 * struct nfp_tun_ipv6_addr - set the IP address list on the NFP 139 * @count: number of IPs populated in the array 140 * @ipv6_addr: array of IPV6_ADDRS_MAX 128 bit IPv6 addresses 141 */ 142 struct nfp_tun_ipv6_addr { 143 __be32 count; 144 struct in6_addr ipv6_addr[NFP_FL_IPV6_ADDRS_MAX]; 145 }; 146 147 #define NFP_TUN_MAC_OFFLOAD_DEL_FLAG 0x2 148 149 /** 150 * struct nfp_tun_mac_addr_offload - configure MAC address of tunnel EP on NFP 151 * @flags: MAC address offload options 152 * @count: number of MAC addresses in the message (should be 1) 153 * @index: index of MAC address in the lookup table 154 * @addr: interface MAC address 155 */ 156 struct nfp_tun_mac_addr_offload { 157 __be16 flags; 158 __be16 count; 159 __be16 index; 160 u8 addr[ETH_ALEN]; 161 }; 162 163 enum nfp_flower_mac_offload_cmd { 164 NFP_TUNNEL_MAC_OFFLOAD_ADD = 0, 165 NFP_TUNNEL_MAC_OFFLOAD_DEL = 1, 166 NFP_TUNNEL_MAC_OFFLOAD_MOD = 2, 167 }; 168 169 #define NFP_MAX_MAC_INDEX 0xff 170 171 /** 172 * struct nfp_tun_offloaded_mac - hashtable entry for an offloaded MAC 173 * @ht_node: Hashtable entry 174 * @addr: Offloaded MAC address 175 * @index: Offloaded index for given MAC address 176 * @ref_count: Number of devs using this MAC address 177 * @repr_list: List of reprs sharing this MAC address 178 * @bridge_count: Number of bridge/internal devs with MAC 179 */ 180 struct nfp_tun_offloaded_mac { 181 struct rhash_head ht_node; 182 u8 addr[ETH_ALEN]; 183 u16 index; 184 int ref_count; 185 struct list_head repr_list; 186 int bridge_count; 187 }; 188 189 static const struct rhashtable_params offloaded_macs_params = { 190 .key_offset = offsetof(struct nfp_tun_offloaded_mac, addr), 191 .head_offset = offsetof(struct nfp_tun_offloaded_mac, ht_node), 192 .key_len = ETH_ALEN, 193 .automatic_shrinking = true, 194 }; 195 196 void nfp_tunnel_keep_alive(struct nfp_app *app, struct sk_buff *skb) 197 { 198 struct nfp_tun_active_tuns *payload; 199 struct net_device *netdev; 200 int count, i, pay_len; 201 struct neighbour *n; 202 __be32 ipv4_addr; 203 u32 port; 204 205 payload = nfp_flower_cmsg_get_data(skb); 206 count = be32_to_cpu(payload->count); 207 if (count > NFP_FL_MAX_ROUTES) { 208 nfp_flower_cmsg_warn(app, "Tunnel keep-alive request exceeds max routes.\n"); 209 return; 210 } 211 212 pay_len = nfp_flower_cmsg_get_data_len(skb); 213 if (pay_len != struct_size(payload, tun_info, count)) { 214 nfp_flower_cmsg_warn(app, "Corruption in tunnel keep-alive message.\n"); 215 return; 216 } 217 218 rcu_read_lock(); 219 for (i = 0; i < count; i++) { 220 ipv4_addr = payload->tun_info[i].ipv4; 221 port = be32_to_cpu(payload->tun_info[i].egress_port); 222 netdev = nfp_app_dev_get(app, port, NULL); 223 if (!netdev) 224 continue; 225 226 n = neigh_lookup(&arp_tbl, &ipv4_addr, netdev); 227 if (!n) 228 continue; 229 230 /* Update the used timestamp of neighbour */ 231 neigh_event_send(n, NULL); 232 neigh_release(n); 233 } 234 rcu_read_unlock(); 235 } 236 237 void nfp_tunnel_keep_alive_v6(struct nfp_app *app, struct sk_buff *skb) 238 { 239 #if IS_ENABLED(CONFIG_IPV6) 240 struct nfp_tun_active_tuns_v6 *payload; 241 struct net_device *netdev; 242 int count, i, pay_len; 243 struct neighbour *n; 244 void *ipv6_add; 245 u32 port; 246 247 payload = nfp_flower_cmsg_get_data(skb); 248 count = be32_to_cpu(payload->count); 249 if (count > NFP_FL_IPV6_ADDRS_MAX) { 250 nfp_flower_cmsg_warn(app, "IPv6 tunnel keep-alive request exceeds max routes.\n"); 251 return; 252 } 253 254 pay_len = nfp_flower_cmsg_get_data_len(skb); 255 if (pay_len != struct_size(payload, tun_info, count)) { 256 nfp_flower_cmsg_warn(app, "Corruption in tunnel keep-alive message.\n"); 257 return; 258 } 259 260 rcu_read_lock(); 261 for (i = 0; i < count; i++) { 262 ipv6_add = &payload->tun_info[i].ipv6; 263 port = be32_to_cpu(payload->tun_info[i].egress_port); 264 netdev = nfp_app_dev_get(app, port, NULL); 265 if (!netdev) 266 continue; 267 268 n = neigh_lookup(&nd_tbl, ipv6_add, netdev); 269 if (!n) 270 continue; 271 272 /* Update the used timestamp of neighbour */ 273 neigh_event_send(n, NULL); 274 neigh_release(n); 275 } 276 rcu_read_unlock(); 277 #endif 278 } 279 280 static int 281 nfp_flower_xmit_tun_conf(struct nfp_app *app, u8 mtype, u16 plen, void *pdata, 282 gfp_t flag) 283 { 284 struct nfp_flower_priv *priv = app->priv; 285 struct sk_buff *skb; 286 unsigned char *msg; 287 288 if (!(priv->flower_ext_feats & NFP_FL_FEATS_DECAP_V2) && 289 (mtype == NFP_FLOWER_CMSG_TYPE_TUN_NEIGH || 290 mtype == NFP_FLOWER_CMSG_TYPE_TUN_NEIGH_V6)) 291 plen -= sizeof(struct nfp_tun_neigh_ext); 292 293 skb = nfp_flower_cmsg_alloc(app, plen, mtype, flag); 294 if (!skb) 295 return -ENOMEM; 296 297 msg = nfp_flower_cmsg_get_data(skb); 298 memcpy(msg, pdata, nfp_flower_cmsg_get_data_len(skb)); 299 300 nfp_ctrl_tx(app->ctrl, skb); 301 return 0; 302 } 303 304 static void 305 nfp_tun_mutual_link(struct nfp_predt_entry *predt, 306 struct nfp_neigh_entry *neigh) 307 { 308 struct nfp_fl_payload *flow_pay = predt->flow_pay; 309 struct nfp_tun_neigh_ext *ext; 310 struct nfp_tun_neigh *common; 311 312 if (flow_pay->pre_tun_rule.is_ipv6 != neigh->is_ipv6) 313 return; 314 315 /* In the case of bonding it is possible that there might already 316 * be a flow linked (as the MAC address gets shared). If a flow 317 * is already linked just return. 318 */ 319 if (neigh->flow) 320 return; 321 322 common = neigh->is_ipv6 ? 323 &((struct nfp_tun_neigh_v6 *)neigh->payload)->common : 324 &((struct nfp_tun_neigh_v4 *)neigh->payload)->common; 325 ext = neigh->is_ipv6 ? 326 &((struct nfp_tun_neigh_v6 *)neigh->payload)->ext : 327 &((struct nfp_tun_neigh_v4 *)neigh->payload)->ext; 328 329 if (memcmp(flow_pay->pre_tun_rule.loc_mac, 330 common->src_addr, ETH_ALEN) || 331 memcmp(flow_pay->pre_tun_rule.rem_mac, 332 common->dst_addr, ETH_ALEN)) 333 return; 334 335 list_add(&neigh->list_head, &predt->nn_list); 336 neigh->flow = predt; 337 ext->host_ctx = flow_pay->meta.host_ctx_id; 338 ext->vlan_tci = flow_pay->pre_tun_rule.vlan_tci; 339 ext->vlan_tpid = flow_pay->pre_tun_rule.vlan_tpid; 340 } 341 342 static void 343 nfp_tun_link_predt_entries(struct nfp_app *app, 344 struct nfp_neigh_entry *nn_entry) 345 { 346 struct nfp_flower_priv *priv = app->priv; 347 struct nfp_predt_entry *predt, *tmp; 348 349 list_for_each_entry_safe(predt, tmp, &priv->predt_list, list_head) { 350 nfp_tun_mutual_link(predt, nn_entry); 351 } 352 } 353 354 void nfp_tun_link_and_update_nn_entries(struct nfp_app *app, 355 struct nfp_predt_entry *predt) 356 { 357 struct nfp_flower_priv *priv = app->priv; 358 struct nfp_neigh_entry *nn_entry; 359 struct rhashtable_iter iter; 360 size_t neigh_size; 361 u8 type; 362 363 rhashtable_walk_enter(&priv->neigh_table, &iter); 364 rhashtable_walk_start(&iter); 365 while ((nn_entry = rhashtable_walk_next(&iter)) != NULL) { 366 if (IS_ERR(nn_entry)) 367 continue; 368 nfp_tun_mutual_link(predt, nn_entry); 369 neigh_size = nn_entry->is_ipv6 ? 370 sizeof(struct nfp_tun_neigh_v6) : 371 sizeof(struct nfp_tun_neigh_v4); 372 type = nn_entry->is_ipv6 ? NFP_FLOWER_CMSG_TYPE_TUN_NEIGH_V6 : 373 NFP_FLOWER_CMSG_TYPE_TUN_NEIGH; 374 nfp_flower_xmit_tun_conf(app, type, neigh_size, 375 nn_entry->payload, 376 GFP_ATOMIC); 377 } 378 rhashtable_walk_stop(&iter); 379 rhashtable_walk_exit(&iter); 380 } 381 382 static void nfp_tun_cleanup_nn_entries(struct nfp_app *app) 383 { 384 struct nfp_flower_priv *priv = app->priv; 385 struct nfp_neigh_entry *neigh; 386 struct nfp_tun_neigh_ext *ext; 387 struct rhashtable_iter iter; 388 size_t neigh_size; 389 u8 type; 390 391 rhashtable_walk_enter(&priv->neigh_table, &iter); 392 rhashtable_walk_start(&iter); 393 while ((neigh = rhashtable_walk_next(&iter)) != NULL) { 394 if (IS_ERR(neigh)) 395 continue; 396 ext = neigh->is_ipv6 ? 397 &((struct nfp_tun_neigh_v6 *)neigh->payload)->ext : 398 &((struct nfp_tun_neigh_v4 *)neigh->payload)->ext; 399 ext->host_ctx = cpu_to_be32(U32_MAX); 400 ext->vlan_tpid = cpu_to_be16(U16_MAX); 401 ext->vlan_tci = cpu_to_be16(U16_MAX); 402 403 neigh_size = neigh->is_ipv6 ? 404 sizeof(struct nfp_tun_neigh_v6) : 405 sizeof(struct nfp_tun_neigh_v4); 406 type = neigh->is_ipv6 ? NFP_FLOWER_CMSG_TYPE_TUN_NEIGH_V6 : 407 NFP_FLOWER_CMSG_TYPE_TUN_NEIGH; 408 nfp_flower_xmit_tun_conf(app, type, neigh_size, neigh->payload, 409 GFP_ATOMIC); 410 411 rhashtable_remove_fast(&priv->neigh_table, &neigh->ht_node, 412 neigh_table_params); 413 if (neigh->flow) 414 list_del(&neigh->list_head); 415 kfree(neigh); 416 } 417 rhashtable_walk_stop(&iter); 418 rhashtable_walk_exit(&iter); 419 } 420 421 void nfp_tun_unlink_and_update_nn_entries(struct nfp_app *app, 422 struct nfp_predt_entry *predt) 423 { 424 struct nfp_neigh_entry *neigh, *tmp; 425 struct nfp_tun_neigh_ext *ext; 426 size_t neigh_size; 427 u8 type; 428 429 list_for_each_entry_safe(neigh, tmp, &predt->nn_list, list_head) { 430 ext = neigh->is_ipv6 ? 431 &((struct nfp_tun_neigh_v6 *)neigh->payload)->ext : 432 &((struct nfp_tun_neigh_v4 *)neigh->payload)->ext; 433 neigh->flow = NULL; 434 ext->host_ctx = cpu_to_be32(U32_MAX); 435 ext->vlan_tpid = cpu_to_be16(U16_MAX); 436 ext->vlan_tci = cpu_to_be16(U16_MAX); 437 list_del(&neigh->list_head); 438 neigh_size = neigh->is_ipv6 ? 439 sizeof(struct nfp_tun_neigh_v6) : 440 sizeof(struct nfp_tun_neigh_v4); 441 type = neigh->is_ipv6 ? NFP_FLOWER_CMSG_TYPE_TUN_NEIGH_V6 : 442 NFP_FLOWER_CMSG_TYPE_TUN_NEIGH; 443 nfp_flower_xmit_tun_conf(app, type, neigh_size, neigh->payload, 444 GFP_ATOMIC); 445 } 446 } 447 448 static void 449 nfp_tun_write_neigh(struct net_device *netdev, struct nfp_app *app, 450 void *flow, struct neighbour *neigh, bool is_ipv6, 451 bool override) 452 { 453 bool neigh_invalid = !(neigh->nud_state & NUD_VALID) || neigh->dead; 454 size_t neigh_size = is_ipv6 ? sizeof(struct nfp_tun_neigh_v6) : 455 sizeof(struct nfp_tun_neigh_v4); 456 unsigned long cookie = (unsigned long)neigh; 457 struct nfp_flower_priv *priv = app->priv; 458 struct nfp_neigh_entry *nn_entry; 459 u32 port_id; 460 u8 mtype; 461 462 port_id = nfp_flower_get_port_id_from_netdev(app, netdev); 463 if (!port_id) 464 return; 465 466 spin_lock_bh(&priv->predt_lock); 467 nn_entry = rhashtable_lookup_fast(&priv->neigh_table, &cookie, 468 neigh_table_params); 469 if (!nn_entry && !neigh_invalid) { 470 struct nfp_tun_neigh_ext *ext; 471 struct nfp_tun_neigh *common; 472 473 nn_entry = kzalloc(sizeof(*nn_entry) + neigh_size, 474 GFP_ATOMIC); 475 if (!nn_entry) 476 goto err; 477 478 nn_entry->payload = (char *)&nn_entry[1]; 479 nn_entry->neigh_cookie = cookie; 480 nn_entry->is_ipv6 = is_ipv6; 481 nn_entry->flow = NULL; 482 if (is_ipv6) { 483 struct flowi6 *flowi6 = (struct flowi6 *)flow; 484 struct nfp_tun_neigh_v6 *payload; 485 486 payload = (struct nfp_tun_neigh_v6 *)nn_entry->payload; 487 payload->src_ipv6 = flowi6->saddr; 488 payload->dst_ipv6 = flowi6->daddr; 489 common = &payload->common; 490 ext = &payload->ext; 491 mtype = NFP_FLOWER_CMSG_TYPE_TUN_NEIGH_V6; 492 } else { 493 struct flowi4 *flowi4 = (struct flowi4 *)flow; 494 struct nfp_tun_neigh_v4 *payload; 495 496 payload = (struct nfp_tun_neigh_v4 *)nn_entry->payload; 497 payload->src_ipv4 = flowi4->saddr; 498 payload->dst_ipv4 = flowi4->daddr; 499 common = &payload->common; 500 ext = &payload->ext; 501 mtype = NFP_FLOWER_CMSG_TYPE_TUN_NEIGH; 502 } 503 ext->host_ctx = cpu_to_be32(U32_MAX); 504 ext->vlan_tpid = cpu_to_be16(U16_MAX); 505 ext->vlan_tci = cpu_to_be16(U16_MAX); 506 ether_addr_copy(common->src_addr, netdev->dev_addr); 507 neigh_ha_snapshot(common->dst_addr, neigh, netdev); 508 common->port_id = cpu_to_be32(port_id); 509 510 if (rhashtable_insert_fast(&priv->neigh_table, 511 &nn_entry->ht_node, 512 neigh_table_params)) 513 goto err; 514 515 nfp_tun_link_predt_entries(app, nn_entry); 516 nfp_flower_xmit_tun_conf(app, mtype, neigh_size, 517 nn_entry->payload, 518 GFP_ATOMIC); 519 } else if (nn_entry && neigh_invalid) { 520 if (is_ipv6) { 521 struct flowi6 *flowi6 = (struct flowi6 *)flow; 522 struct nfp_tun_neigh_v6 *payload; 523 524 payload = (struct nfp_tun_neigh_v6 *)nn_entry->payload; 525 memset(payload, 0, sizeof(struct nfp_tun_neigh_v6)); 526 payload->dst_ipv6 = flowi6->daddr; 527 mtype = NFP_FLOWER_CMSG_TYPE_TUN_NEIGH_V6; 528 } else { 529 struct flowi4 *flowi4 = (struct flowi4 *)flow; 530 struct nfp_tun_neigh_v4 *payload; 531 532 payload = (struct nfp_tun_neigh_v4 *)nn_entry->payload; 533 memset(payload, 0, sizeof(struct nfp_tun_neigh_v4)); 534 payload->dst_ipv4 = flowi4->daddr; 535 mtype = NFP_FLOWER_CMSG_TYPE_TUN_NEIGH; 536 } 537 /* Trigger ARP to verify invalid neighbour state. */ 538 neigh_event_send(neigh, NULL); 539 rhashtable_remove_fast(&priv->neigh_table, 540 &nn_entry->ht_node, 541 neigh_table_params); 542 543 nfp_flower_xmit_tun_conf(app, mtype, neigh_size, 544 nn_entry->payload, 545 GFP_ATOMIC); 546 547 if (nn_entry->flow) 548 list_del(&nn_entry->list_head); 549 kfree(nn_entry); 550 } else if (nn_entry && !neigh_invalid && override) { 551 mtype = is_ipv6 ? NFP_FLOWER_CMSG_TYPE_TUN_NEIGH_V6 : 552 NFP_FLOWER_CMSG_TYPE_TUN_NEIGH; 553 nfp_tun_link_predt_entries(app, nn_entry); 554 nfp_flower_xmit_tun_conf(app, mtype, neigh_size, 555 nn_entry->payload, 556 GFP_ATOMIC); 557 } 558 559 spin_unlock_bh(&priv->predt_lock); 560 return; 561 562 err: 563 kfree(nn_entry); 564 spin_unlock_bh(&priv->predt_lock); 565 nfp_flower_cmsg_warn(app, "Neighbour configuration failed.\n"); 566 } 567 568 static int 569 nfp_tun_neigh_event_handler(struct notifier_block *nb, unsigned long event, 570 void *ptr) 571 { 572 struct nfp_flower_priv *app_priv; 573 struct netevent_redirect *redir; 574 struct neighbour *n; 575 struct nfp_app *app; 576 bool neigh_invalid; 577 int err; 578 579 switch (event) { 580 case NETEVENT_REDIRECT: 581 redir = (struct netevent_redirect *)ptr; 582 n = redir->neigh; 583 break; 584 case NETEVENT_NEIGH_UPDATE: 585 n = (struct neighbour *)ptr; 586 break; 587 default: 588 return NOTIFY_DONE; 589 } 590 591 neigh_invalid = !(n->nud_state & NUD_VALID) || n->dead; 592 593 app_priv = container_of(nb, struct nfp_flower_priv, tun.neigh_nb); 594 app = app_priv->app; 595 596 if (!nfp_netdev_is_nfp_repr(n->dev) && 597 !nfp_flower_internal_port_can_offload(app, n->dev)) 598 return NOTIFY_DONE; 599 600 #if IS_ENABLED(CONFIG_INET) 601 if (n->tbl->family == AF_INET6) { 602 #if IS_ENABLED(CONFIG_IPV6) 603 struct flowi6 flow6 = {}; 604 605 flow6.daddr = *(struct in6_addr *)n->primary_key; 606 if (!neigh_invalid) { 607 struct dst_entry *dst; 608 /* Use ipv6_dst_lookup_flow to populate flow6->saddr 609 * and other fields. This information is only needed 610 * for new entries, lookup can be skipped when an entry 611 * gets invalidated - as only the daddr is needed for 612 * deleting. 613 */ 614 dst = ip6_dst_lookup_flow(dev_net(n->dev), NULL, 615 &flow6, NULL); 616 if (IS_ERR(dst)) 617 return NOTIFY_DONE; 618 619 dst_release(dst); 620 } 621 nfp_tun_write_neigh(n->dev, app, &flow6, n, true, false); 622 #else 623 return NOTIFY_DONE; 624 #endif /* CONFIG_IPV6 */ 625 } else { 626 struct flowi4 flow4 = {}; 627 628 flow4.daddr = *(__be32 *)n->primary_key; 629 if (!neigh_invalid) { 630 struct rtable *rt; 631 /* Use ip_route_output_key to populate flow4->saddr and 632 * other fields. This information is only needed for 633 * new entries, lookup can be skipped when an entry 634 * gets invalidated - as only the daddr is needed for 635 * deleting. 636 */ 637 rt = ip_route_output_key(dev_net(n->dev), &flow4); 638 err = PTR_ERR_OR_ZERO(rt); 639 if (err) 640 return NOTIFY_DONE; 641 642 ip_rt_put(rt); 643 } 644 nfp_tun_write_neigh(n->dev, app, &flow4, n, false, false); 645 } 646 #else 647 return NOTIFY_DONE; 648 #endif /* CONFIG_INET */ 649 650 return NOTIFY_OK; 651 } 652 653 void nfp_tunnel_request_route_v4(struct nfp_app *app, struct sk_buff *skb) 654 { 655 struct nfp_tun_req_route_ipv4 *payload; 656 struct net_device *netdev; 657 struct flowi4 flow = {}; 658 struct neighbour *n; 659 struct rtable *rt; 660 int err; 661 662 payload = nfp_flower_cmsg_get_data(skb); 663 664 rcu_read_lock(); 665 netdev = nfp_app_dev_get(app, be32_to_cpu(payload->ingress_port), NULL); 666 if (!netdev) 667 goto fail_rcu_unlock; 668 669 flow.daddr = payload->ipv4_addr; 670 flow.flowi4_proto = IPPROTO_UDP; 671 672 #if IS_ENABLED(CONFIG_INET) 673 /* Do a route lookup on same namespace as ingress port. */ 674 rt = ip_route_output_key(dev_net(netdev), &flow); 675 err = PTR_ERR_OR_ZERO(rt); 676 if (err) 677 goto fail_rcu_unlock; 678 #else 679 goto fail_rcu_unlock; 680 #endif 681 682 /* Get the neighbour entry for the lookup */ 683 n = dst_neigh_lookup(&rt->dst, &flow.daddr); 684 ip_rt_put(rt); 685 if (!n) 686 goto fail_rcu_unlock; 687 nfp_tun_write_neigh(n->dev, app, &flow, n, false, true); 688 neigh_release(n); 689 rcu_read_unlock(); 690 return; 691 692 fail_rcu_unlock: 693 rcu_read_unlock(); 694 nfp_flower_cmsg_warn(app, "Requested route not found.\n"); 695 } 696 697 void nfp_tunnel_request_route_v6(struct nfp_app *app, struct sk_buff *skb) 698 { 699 struct nfp_tun_req_route_ipv6 *payload; 700 struct net_device *netdev; 701 struct flowi6 flow = {}; 702 struct dst_entry *dst; 703 struct neighbour *n; 704 705 payload = nfp_flower_cmsg_get_data(skb); 706 707 rcu_read_lock(); 708 netdev = nfp_app_dev_get(app, be32_to_cpu(payload->ingress_port), NULL); 709 if (!netdev) 710 goto fail_rcu_unlock; 711 712 flow.daddr = payload->ipv6_addr; 713 flow.flowi6_proto = IPPROTO_UDP; 714 715 #if IS_ENABLED(CONFIG_INET) && IS_ENABLED(CONFIG_IPV6) 716 dst = ipv6_stub->ipv6_dst_lookup_flow(dev_net(netdev), NULL, &flow, 717 NULL); 718 if (IS_ERR(dst)) 719 goto fail_rcu_unlock; 720 #else 721 goto fail_rcu_unlock; 722 #endif 723 724 n = dst_neigh_lookup(dst, &flow.daddr); 725 dst_release(dst); 726 if (!n) 727 goto fail_rcu_unlock; 728 729 nfp_tun_write_neigh(n->dev, app, &flow, n, true, true); 730 neigh_release(n); 731 rcu_read_unlock(); 732 return; 733 734 fail_rcu_unlock: 735 rcu_read_unlock(); 736 nfp_flower_cmsg_warn(app, "Requested IPv6 route not found.\n"); 737 } 738 739 static void nfp_tun_write_ipv4_list(struct nfp_app *app) 740 { 741 struct nfp_flower_priv *priv = app->priv; 742 struct nfp_ipv4_addr_entry *entry; 743 struct nfp_tun_ipv4_addr payload; 744 struct list_head *ptr, *storage; 745 int count; 746 747 memset(&payload, 0, sizeof(struct nfp_tun_ipv4_addr)); 748 mutex_lock(&priv->tun.ipv4_off_lock); 749 count = 0; 750 list_for_each_safe(ptr, storage, &priv->tun.ipv4_off_list) { 751 if (count >= NFP_FL_IPV4_ADDRS_MAX) { 752 mutex_unlock(&priv->tun.ipv4_off_lock); 753 nfp_flower_cmsg_warn(app, "IPv4 offload exceeds limit.\n"); 754 return; 755 } 756 entry = list_entry(ptr, struct nfp_ipv4_addr_entry, list); 757 payload.ipv4_addr[count++] = entry->ipv4_addr; 758 } 759 payload.count = cpu_to_be32(count); 760 mutex_unlock(&priv->tun.ipv4_off_lock); 761 762 nfp_flower_xmit_tun_conf(app, NFP_FLOWER_CMSG_TYPE_TUN_IPS, 763 sizeof(struct nfp_tun_ipv4_addr), 764 &payload, GFP_KERNEL); 765 } 766 767 void nfp_tunnel_add_ipv4_off(struct nfp_app *app, __be32 ipv4) 768 { 769 struct nfp_flower_priv *priv = app->priv; 770 struct nfp_ipv4_addr_entry *entry; 771 struct list_head *ptr, *storage; 772 773 mutex_lock(&priv->tun.ipv4_off_lock); 774 list_for_each_safe(ptr, storage, &priv->tun.ipv4_off_list) { 775 entry = list_entry(ptr, struct nfp_ipv4_addr_entry, list); 776 if (entry->ipv4_addr == ipv4) { 777 entry->ref_count++; 778 mutex_unlock(&priv->tun.ipv4_off_lock); 779 return; 780 } 781 } 782 783 entry = kmalloc(sizeof(*entry), GFP_KERNEL); 784 if (!entry) { 785 mutex_unlock(&priv->tun.ipv4_off_lock); 786 nfp_flower_cmsg_warn(app, "Mem error when offloading IP address.\n"); 787 return; 788 } 789 entry->ipv4_addr = ipv4; 790 entry->ref_count = 1; 791 list_add_tail(&entry->list, &priv->tun.ipv4_off_list); 792 mutex_unlock(&priv->tun.ipv4_off_lock); 793 794 nfp_tun_write_ipv4_list(app); 795 } 796 797 void nfp_tunnel_del_ipv4_off(struct nfp_app *app, __be32 ipv4) 798 { 799 struct nfp_flower_priv *priv = app->priv; 800 struct nfp_ipv4_addr_entry *entry; 801 struct list_head *ptr, *storage; 802 803 mutex_lock(&priv->tun.ipv4_off_lock); 804 list_for_each_safe(ptr, storage, &priv->tun.ipv4_off_list) { 805 entry = list_entry(ptr, struct nfp_ipv4_addr_entry, list); 806 if (entry->ipv4_addr == ipv4) { 807 entry->ref_count--; 808 if (!entry->ref_count) { 809 list_del(&entry->list); 810 kfree(entry); 811 } 812 break; 813 } 814 } 815 mutex_unlock(&priv->tun.ipv4_off_lock); 816 817 nfp_tun_write_ipv4_list(app); 818 } 819 820 static void nfp_tun_write_ipv6_list(struct nfp_app *app) 821 { 822 struct nfp_flower_priv *priv = app->priv; 823 struct nfp_ipv6_addr_entry *entry; 824 struct nfp_tun_ipv6_addr payload; 825 int count = 0; 826 827 memset(&payload, 0, sizeof(struct nfp_tun_ipv6_addr)); 828 mutex_lock(&priv->tun.ipv6_off_lock); 829 list_for_each_entry(entry, &priv->tun.ipv6_off_list, list) { 830 if (count >= NFP_FL_IPV6_ADDRS_MAX) { 831 nfp_flower_cmsg_warn(app, "Too many IPv6 tunnel endpoint addresses, some cannot be offloaded.\n"); 832 break; 833 } 834 payload.ipv6_addr[count++] = entry->ipv6_addr; 835 } 836 mutex_unlock(&priv->tun.ipv6_off_lock); 837 payload.count = cpu_to_be32(count); 838 839 nfp_flower_xmit_tun_conf(app, NFP_FLOWER_CMSG_TYPE_TUN_IPS_V6, 840 sizeof(struct nfp_tun_ipv6_addr), 841 &payload, GFP_KERNEL); 842 } 843 844 struct nfp_ipv6_addr_entry * 845 nfp_tunnel_add_ipv6_off(struct nfp_app *app, struct in6_addr *ipv6) 846 { 847 struct nfp_flower_priv *priv = app->priv; 848 struct nfp_ipv6_addr_entry *entry; 849 850 mutex_lock(&priv->tun.ipv6_off_lock); 851 list_for_each_entry(entry, &priv->tun.ipv6_off_list, list) 852 if (!memcmp(&entry->ipv6_addr, ipv6, sizeof(*ipv6))) { 853 entry->ref_count++; 854 mutex_unlock(&priv->tun.ipv6_off_lock); 855 return entry; 856 } 857 858 entry = kmalloc(sizeof(*entry), GFP_KERNEL); 859 if (!entry) { 860 mutex_unlock(&priv->tun.ipv6_off_lock); 861 nfp_flower_cmsg_warn(app, "Mem error when offloading IP address.\n"); 862 return NULL; 863 } 864 entry->ipv6_addr = *ipv6; 865 entry->ref_count = 1; 866 list_add_tail(&entry->list, &priv->tun.ipv6_off_list); 867 mutex_unlock(&priv->tun.ipv6_off_lock); 868 869 nfp_tun_write_ipv6_list(app); 870 871 return entry; 872 } 873 874 void 875 nfp_tunnel_put_ipv6_off(struct nfp_app *app, struct nfp_ipv6_addr_entry *entry) 876 { 877 struct nfp_flower_priv *priv = app->priv; 878 bool freed = false; 879 880 mutex_lock(&priv->tun.ipv6_off_lock); 881 if (!--entry->ref_count) { 882 list_del(&entry->list); 883 kfree(entry); 884 freed = true; 885 } 886 mutex_unlock(&priv->tun.ipv6_off_lock); 887 888 if (freed) 889 nfp_tun_write_ipv6_list(app); 890 } 891 892 static int 893 __nfp_tunnel_offload_mac(struct nfp_app *app, const u8 *mac, u16 idx, bool del) 894 { 895 struct nfp_tun_mac_addr_offload payload; 896 897 memset(&payload, 0, sizeof(payload)); 898 899 if (del) 900 payload.flags = cpu_to_be16(NFP_TUN_MAC_OFFLOAD_DEL_FLAG); 901 902 /* FW supports multiple MACs per cmsg but restrict to single. */ 903 payload.count = cpu_to_be16(1); 904 payload.index = cpu_to_be16(idx); 905 ether_addr_copy(payload.addr, mac); 906 907 return nfp_flower_xmit_tun_conf(app, NFP_FLOWER_CMSG_TYPE_TUN_MAC, 908 sizeof(struct nfp_tun_mac_addr_offload), 909 &payload, GFP_KERNEL); 910 } 911 912 static bool nfp_tunnel_port_is_phy_repr(int port) 913 { 914 if (FIELD_GET(NFP_FLOWER_CMSG_PORT_TYPE, port) == 915 NFP_FLOWER_CMSG_PORT_TYPE_PHYS_PORT) 916 return true; 917 918 return false; 919 } 920 921 static u16 nfp_tunnel_get_mac_idx_from_phy_port_id(int port) 922 { 923 return port << 8 | NFP_FLOWER_CMSG_PORT_TYPE_PHYS_PORT; 924 } 925 926 static u16 nfp_tunnel_get_global_mac_idx_from_ida(int id) 927 { 928 return id << 8 | NFP_FLOWER_CMSG_PORT_TYPE_OTHER_PORT; 929 } 930 931 static int nfp_tunnel_get_ida_from_global_mac_idx(u16 nfp_mac_idx) 932 { 933 return nfp_mac_idx >> 8; 934 } 935 936 static bool nfp_tunnel_is_mac_idx_global(u16 nfp_mac_idx) 937 { 938 return (nfp_mac_idx & 0xff) == NFP_FLOWER_CMSG_PORT_TYPE_OTHER_PORT; 939 } 940 941 static struct nfp_tun_offloaded_mac * 942 nfp_tunnel_lookup_offloaded_macs(struct nfp_app *app, const u8 *mac) 943 { 944 struct nfp_flower_priv *priv = app->priv; 945 946 return rhashtable_lookup_fast(&priv->tun.offloaded_macs, mac, 947 offloaded_macs_params); 948 } 949 950 static void 951 nfp_tunnel_offloaded_macs_inc_ref_and_link(struct nfp_tun_offloaded_mac *entry, 952 struct net_device *netdev, bool mod) 953 { 954 if (nfp_netdev_is_nfp_repr(netdev)) { 955 struct nfp_flower_repr_priv *repr_priv; 956 struct nfp_repr *repr; 957 958 repr = netdev_priv(netdev); 959 repr_priv = repr->app_priv; 960 961 /* If modifing MAC, remove repr from old list first. */ 962 if (mod) 963 list_del(&repr_priv->mac_list); 964 965 list_add_tail(&repr_priv->mac_list, &entry->repr_list); 966 } else if (nfp_flower_is_supported_bridge(netdev)) { 967 entry->bridge_count++; 968 } 969 970 entry->ref_count++; 971 } 972 973 static int 974 nfp_tunnel_add_shared_mac(struct nfp_app *app, struct net_device *netdev, 975 int port, bool mod) 976 { 977 struct nfp_flower_priv *priv = app->priv; 978 struct nfp_tun_offloaded_mac *entry; 979 int ida_idx = -1, err; 980 u16 nfp_mac_idx = 0; 981 982 entry = nfp_tunnel_lookup_offloaded_macs(app, netdev->dev_addr); 983 if (entry && nfp_tunnel_is_mac_idx_global(entry->index)) { 984 if (entry->bridge_count || 985 !nfp_flower_is_supported_bridge(netdev)) { 986 nfp_tunnel_offloaded_macs_inc_ref_and_link(entry, 987 netdev, mod); 988 return 0; 989 } 990 991 /* MAC is global but matches need to go to pre_tun table. */ 992 nfp_mac_idx = entry->index | NFP_TUN_PRE_TUN_IDX_BIT; 993 } 994 995 if (!nfp_mac_idx) { 996 /* Assign a global index if non-repr or MAC is now shared. */ 997 if (entry || !port) { 998 ida_idx = ida_alloc_max(&priv->tun.mac_off_ids, 999 NFP_MAX_MAC_INDEX, GFP_KERNEL); 1000 if (ida_idx < 0) 1001 return ida_idx; 1002 1003 nfp_mac_idx = 1004 nfp_tunnel_get_global_mac_idx_from_ida(ida_idx); 1005 1006 if (nfp_flower_is_supported_bridge(netdev)) 1007 nfp_mac_idx |= NFP_TUN_PRE_TUN_IDX_BIT; 1008 1009 } else { 1010 nfp_mac_idx = 1011 nfp_tunnel_get_mac_idx_from_phy_port_id(port); 1012 } 1013 } 1014 1015 if (!entry) { 1016 entry = kzalloc(sizeof(*entry), GFP_KERNEL); 1017 if (!entry) { 1018 err = -ENOMEM; 1019 goto err_free_ida; 1020 } 1021 1022 ether_addr_copy(entry->addr, netdev->dev_addr); 1023 INIT_LIST_HEAD(&entry->repr_list); 1024 1025 if (rhashtable_insert_fast(&priv->tun.offloaded_macs, 1026 &entry->ht_node, 1027 offloaded_macs_params)) { 1028 err = -ENOMEM; 1029 goto err_free_entry; 1030 } 1031 } 1032 1033 err = __nfp_tunnel_offload_mac(app, netdev->dev_addr, 1034 nfp_mac_idx, false); 1035 if (err) { 1036 /* If not shared then free. */ 1037 if (!entry->ref_count) 1038 goto err_remove_hash; 1039 goto err_free_ida; 1040 } 1041 1042 entry->index = nfp_mac_idx; 1043 nfp_tunnel_offloaded_macs_inc_ref_and_link(entry, netdev, mod); 1044 1045 return 0; 1046 1047 err_remove_hash: 1048 rhashtable_remove_fast(&priv->tun.offloaded_macs, &entry->ht_node, 1049 offloaded_macs_params); 1050 err_free_entry: 1051 kfree(entry); 1052 err_free_ida: 1053 if (ida_idx != -1) 1054 ida_free(&priv->tun.mac_off_ids, ida_idx); 1055 1056 return err; 1057 } 1058 1059 static int 1060 nfp_tunnel_del_shared_mac(struct nfp_app *app, struct net_device *netdev, 1061 const u8 *mac, bool mod) 1062 { 1063 struct nfp_flower_priv *priv = app->priv; 1064 struct nfp_flower_repr_priv *repr_priv; 1065 struct nfp_tun_offloaded_mac *entry; 1066 struct nfp_repr *repr; 1067 u16 nfp_mac_idx; 1068 int ida_idx; 1069 1070 entry = nfp_tunnel_lookup_offloaded_macs(app, mac); 1071 if (!entry) 1072 return 0; 1073 1074 entry->ref_count--; 1075 /* If del is part of a mod then mac_list is still in use elsewheree. */ 1076 if (nfp_netdev_is_nfp_repr(netdev) && !mod) { 1077 repr = netdev_priv(netdev); 1078 repr_priv = repr->app_priv; 1079 list_del(&repr_priv->mac_list); 1080 } 1081 1082 if (nfp_flower_is_supported_bridge(netdev)) { 1083 entry->bridge_count--; 1084 1085 if (!entry->bridge_count && entry->ref_count) { 1086 nfp_mac_idx = entry->index & ~NFP_TUN_PRE_TUN_IDX_BIT; 1087 if (__nfp_tunnel_offload_mac(app, mac, nfp_mac_idx, 1088 false)) { 1089 nfp_flower_cmsg_warn(app, "MAC offload index revert failed on %s.\n", 1090 netdev_name(netdev)); 1091 return 0; 1092 } 1093 1094 entry->index = nfp_mac_idx; 1095 return 0; 1096 } 1097 } 1098 1099 /* If MAC is now used by 1 repr set the offloaded MAC index to port. */ 1100 if (entry->ref_count == 1 && list_is_singular(&entry->repr_list)) { 1101 int port, err; 1102 1103 repr_priv = list_first_entry(&entry->repr_list, 1104 struct nfp_flower_repr_priv, 1105 mac_list); 1106 repr = repr_priv->nfp_repr; 1107 port = nfp_repr_get_port_id(repr->netdev); 1108 nfp_mac_idx = nfp_tunnel_get_mac_idx_from_phy_port_id(port); 1109 err = __nfp_tunnel_offload_mac(app, mac, nfp_mac_idx, false); 1110 if (err) { 1111 nfp_flower_cmsg_warn(app, "MAC offload index revert failed on %s.\n", 1112 netdev_name(netdev)); 1113 return 0; 1114 } 1115 1116 ida_idx = nfp_tunnel_get_ida_from_global_mac_idx(entry->index); 1117 ida_free(&priv->tun.mac_off_ids, ida_idx); 1118 entry->index = nfp_mac_idx; 1119 return 0; 1120 } 1121 1122 if (entry->ref_count) 1123 return 0; 1124 1125 WARN_ON_ONCE(rhashtable_remove_fast(&priv->tun.offloaded_macs, 1126 &entry->ht_node, 1127 offloaded_macs_params)); 1128 1129 if (nfp_flower_is_supported_bridge(netdev)) 1130 nfp_mac_idx = entry->index & ~NFP_TUN_PRE_TUN_IDX_BIT; 1131 else 1132 nfp_mac_idx = entry->index; 1133 1134 /* If MAC has global ID then extract and free the ida entry. */ 1135 if (nfp_tunnel_is_mac_idx_global(nfp_mac_idx)) { 1136 ida_idx = nfp_tunnel_get_ida_from_global_mac_idx(entry->index); 1137 ida_free(&priv->tun.mac_off_ids, ida_idx); 1138 } 1139 1140 kfree(entry); 1141 1142 return __nfp_tunnel_offload_mac(app, mac, 0, true); 1143 } 1144 1145 static int 1146 nfp_tunnel_offload_mac(struct nfp_app *app, struct net_device *netdev, 1147 enum nfp_flower_mac_offload_cmd cmd) 1148 { 1149 struct nfp_flower_non_repr_priv *nr_priv = NULL; 1150 bool non_repr = false, *mac_offloaded; 1151 u8 *off_mac = NULL; 1152 int err, port = 0; 1153 1154 if (nfp_netdev_is_nfp_repr(netdev)) { 1155 struct nfp_flower_repr_priv *repr_priv; 1156 struct nfp_repr *repr; 1157 1158 repr = netdev_priv(netdev); 1159 if (repr->app != app) 1160 return 0; 1161 1162 repr_priv = repr->app_priv; 1163 if (repr_priv->on_bridge) 1164 return 0; 1165 1166 mac_offloaded = &repr_priv->mac_offloaded; 1167 off_mac = &repr_priv->offloaded_mac_addr[0]; 1168 port = nfp_repr_get_port_id(netdev); 1169 if (!nfp_tunnel_port_is_phy_repr(port)) 1170 return 0; 1171 } else if (nfp_fl_is_netdev_to_offload(netdev)) { 1172 nr_priv = nfp_flower_non_repr_priv_get(app, netdev); 1173 if (!nr_priv) 1174 return -ENOMEM; 1175 1176 mac_offloaded = &nr_priv->mac_offloaded; 1177 off_mac = &nr_priv->offloaded_mac_addr[0]; 1178 non_repr = true; 1179 } else { 1180 return 0; 1181 } 1182 1183 if (!is_valid_ether_addr(netdev->dev_addr)) { 1184 err = -EINVAL; 1185 goto err_put_non_repr_priv; 1186 } 1187 1188 if (cmd == NFP_TUNNEL_MAC_OFFLOAD_MOD && !*mac_offloaded) 1189 cmd = NFP_TUNNEL_MAC_OFFLOAD_ADD; 1190 1191 switch (cmd) { 1192 case NFP_TUNNEL_MAC_OFFLOAD_ADD: 1193 err = nfp_tunnel_add_shared_mac(app, netdev, port, false); 1194 if (err) 1195 goto err_put_non_repr_priv; 1196 1197 if (non_repr) 1198 __nfp_flower_non_repr_priv_get(nr_priv); 1199 1200 *mac_offloaded = true; 1201 ether_addr_copy(off_mac, netdev->dev_addr); 1202 break; 1203 case NFP_TUNNEL_MAC_OFFLOAD_DEL: 1204 /* Only attempt delete if add was successful. */ 1205 if (!*mac_offloaded) 1206 break; 1207 1208 if (non_repr) 1209 __nfp_flower_non_repr_priv_put(nr_priv); 1210 1211 *mac_offloaded = false; 1212 1213 err = nfp_tunnel_del_shared_mac(app, netdev, netdev->dev_addr, 1214 false); 1215 if (err) 1216 goto err_put_non_repr_priv; 1217 1218 break; 1219 case NFP_TUNNEL_MAC_OFFLOAD_MOD: 1220 /* Ignore if changing to the same address. */ 1221 if (ether_addr_equal(netdev->dev_addr, off_mac)) 1222 break; 1223 1224 err = nfp_tunnel_add_shared_mac(app, netdev, port, true); 1225 if (err) 1226 goto err_put_non_repr_priv; 1227 1228 /* Delete the previous MAC address. */ 1229 err = nfp_tunnel_del_shared_mac(app, netdev, off_mac, true); 1230 if (err) 1231 nfp_flower_cmsg_warn(app, "Failed to remove offload of replaced MAC addr on %s.\n", 1232 netdev_name(netdev)); 1233 1234 ether_addr_copy(off_mac, netdev->dev_addr); 1235 break; 1236 default: 1237 err = -EINVAL; 1238 goto err_put_non_repr_priv; 1239 } 1240 1241 if (non_repr) 1242 __nfp_flower_non_repr_priv_put(nr_priv); 1243 1244 return 0; 1245 1246 err_put_non_repr_priv: 1247 if (non_repr) 1248 __nfp_flower_non_repr_priv_put(nr_priv); 1249 1250 return err; 1251 } 1252 1253 int nfp_tunnel_mac_event_handler(struct nfp_app *app, 1254 struct net_device *netdev, 1255 unsigned long event, void *ptr) 1256 { 1257 int err; 1258 1259 if (event == NETDEV_DOWN) { 1260 err = nfp_tunnel_offload_mac(app, netdev, 1261 NFP_TUNNEL_MAC_OFFLOAD_DEL); 1262 if (err) 1263 nfp_flower_cmsg_warn(app, "Failed to delete offload MAC on %s.\n", 1264 netdev_name(netdev)); 1265 } else if (event == NETDEV_UP) { 1266 err = nfp_tunnel_offload_mac(app, netdev, 1267 NFP_TUNNEL_MAC_OFFLOAD_ADD); 1268 if (err) 1269 nfp_flower_cmsg_warn(app, "Failed to offload MAC on %s.\n", 1270 netdev_name(netdev)); 1271 } else if (event == NETDEV_CHANGEADDR) { 1272 /* Only offload addr change if netdev is already up. */ 1273 if (!(netdev->flags & IFF_UP)) 1274 return NOTIFY_OK; 1275 1276 err = nfp_tunnel_offload_mac(app, netdev, 1277 NFP_TUNNEL_MAC_OFFLOAD_MOD); 1278 if (err) 1279 nfp_flower_cmsg_warn(app, "Failed to offload MAC change on %s.\n", 1280 netdev_name(netdev)); 1281 } else if (event == NETDEV_CHANGEUPPER) { 1282 /* If a repr is attached to a bridge then tunnel packets 1283 * entering the physical port are directed through the bridge 1284 * datapath and cannot be directly detunneled. Therefore, 1285 * associated offloaded MACs and indexes should not be used 1286 * by fw for detunneling. 1287 */ 1288 struct netdev_notifier_changeupper_info *info = ptr; 1289 struct net_device *upper = info->upper_dev; 1290 struct nfp_flower_repr_priv *repr_priv; 1291 struct nfp_repr *repr; 1292 1293 if (!nfp_netdev_is_nfp_repr(netdev) || 1294 !nfp_flower_is_supported_bridge(upper)) 1295 return NOTIFY_OK; 1296 1297 repr = netdev_priv(netdev); 1298 if (repr->app != app) 1299 return NOTIFY_OK; 1300 1301 repr_priv = repr->app_priv; 1302 1303 if (info->linking) { 1304 if (nfp_tunnel_offload_mac(app, netdev, 1305 NFP_TUNNEL_MAC_OFFLOAD_DEL)) 1306 nfp_flower_cmsg_warn(app, "Failed to delete offloaded MAC on %s.\n", 1307 netdev_name(netdev)); 1308 repr_priv->on_bridge = true; 1309 } else { 1310 repr_priv->on_bridge = false; 1311 1312 if (!(netdev->flags & IFF_UP)) 1313 return NOTIFY_OK; 1314 1315 if (nfp_tunnel_offload_mac(app, netdev, 1316 NFP_TUNNEL_MAC_OFFLOAD_ADD)) 1317 nfp_flower_cmsg_warn(app, "Failed to offload MAC on %s.\n", 1318 netdev_name(netdev)); 1319 } 1320 } 1321 return NOTIFY_OK; 1322 } 1323 1324 int nfp_flower_xmit_pre_tun_flow(struct nfp_app *app, 1325 struct nfp_fl_payload *flow) 1326 { 1327 struct nfp_flower_priv *app_priv = app->priv; 1328 struct nfp_tun_offloaded_mac *mac_entry; 1329 struct nfp_flower_meta_tci *key_meta; 1330 struct nfp_tun_pre_tun_rule payload; 1331 struct net_device *internal_dev; 1332 int err; 1333 1334 if (app_priv->pre_tun_rule_cnt == NFP_TUN_PRE_TUN_RULE_LIMIT) 1335 return -ENOSPC; 1336 1337 memset(&payload, 0, sizeof(struct nfp_tun_pre_tun_rule)); 1338 1339 internal_dev = flow->pre_tun_rule.dev; 1340 payload.vlan_tci = flow->pre_tun_rule.vlan_tci; 1341 payload.host_ctx_id = flow->meta.host_ctx_id; 1342 1343 /* Lookup MAC index for the pre-tunnel rule egress device. 1344 * Note that because the device is always an internal port, it will 1345 * have a constant global index so does not need to be tracked. 1346 */ 1347 mac_entry = nfp_tunnel_lookup_offloaded_macs(app, 1348 internal_dev->dev_addr); 1349 if (!mac_entry) 1350 return -ENOENT; 1351 1352 /* Set/clear IPV6 bit. cpu_to_be16() swap will lead to MSB being 1353 * set/clear for port_idx. 1354 */ 1355 key_meta = (struct nfp_flower_meta_tci *)flow->unmasked_data; 1356 if (key_meta->nfp_flow_key_layer & NFP_FLOWER_LAYER_IPV6) 1357 mac_entry->index |= NFP_TUN_PRE_TUN_IPV6_BIT; 1358 else 1359 mac_entry->index &= ~NFP_TUN_PRE_TUN_IPV6_BIT; 1360 1361 payload.port_idx = cpu_to_be16(mac_entry->index); 1362 1363 /* Copy mac id and vlan to flow - dev may not exist at delete time. */ 1364 flow->pre_tun_rule.vlan_tci = payload.vlan_tci; 1365 flow->pre_tun_rule.port_idx = payload.port_idx; 1366 1367 err = nfp_flower_xmit_tun_conf(app, NFP_FLOWER_CMSG_TYPE_PRE_TUN_RULE, 1368 sizeof(struct nfp_tun_pre_tun_rule), 1369 (unsigned char *)&payload, GFP_KERNEL); 1370 if (err) 1371 return err; 1372 1373 app_priv->pre_tun_rule_cnt++; 1374 1375 return 0; 1376 } 1377 1378 int nfp_flower_xmit_pre_tun_del_flow(struct nfp_app *app, 1379 struct nfp_fl_payload *flow) 1380 { 1381 struct nfp_flower_priv *app_priv = app->priv; 1382 struct nfp_tun_pre_tun_rule payload; 1383 u32 tmp_flags = 0; 1384 int err; 1385 1386 memset(&payload, 0, sizeof(struct nfp_tun_pre_tun_rule)); 1387 1388 tmp_flags |= NFP_TUN_PRE_TUN_RULE_DEL; 1389 payload.flags = cpu_to_be32(tmp_flags); 1390 payload.vlan_tci = flow->pre_tun_rule.vlan_tci; 1391 payload.port_idx = flow->pre_tun_rule.port_idx; 1392 1393 err = nfp_flower_xmit_tun_conf(app, NFP_FLOWER_CMSG_TYPE_PRE_TUN_RULE, 1394 sizeof(struct nfp_tun_pre_tun_rule), 1395 (unsigned char *)&payload, GFP_KERNEL); 1396 if (err) 1397 return err; 1398 1399 app_priv->pre_tun_rule_cnt--; 1400 1401 return 0; 1402 } 1403 1404 int nfp_tunnel_config_start(struct nfp_app *app) 1405 { 1406 struct nfp_flower_priv *priv = app->priv; 1407 int err; 1408 1409 /* Initialise rhash for MAC offload tracking. */ 1410 err = rhashtable_init(&priv->tun.offloaded_macs, 1411 &offloaded_macs_params); 1412 if (err) 1413 return err; 1414 1415 ida_init(&priv->tun.mac_off_ids); 1416 1417 /* Initialise priv data for IPv4/v6 offloading. */ 1418 mutex_init(&priv->tun.ipv4_off_lock); 1419 INIT_LIST_HEAD(&priv->tun.ipv4_off_list); 1420 mutex_init(&priv->tun.ipv6_off_lock); 1421 INIT_LIST_HEAD(&priv->tun.ipv6_off_list); 1422 1423 /* Initialise priv data for neighbour offloading. */ 1424 priv->tun.neigh_nb.notifier_call = nfp_tun_neigh_event_handler; 1425 1426 err = register_netevent_notifier(&priv->tun.neigh_nb); 1427 if (err) { 1428 rhashtable_free_and_destroy(&priv->tun.offloaded_macs, 1429 nfp_check_rhashtable_empty, NULL); 1430 return err; 1431 } 1432 1433 return 0; 1434 } 1435 1436 void nfp_tunnel_config_stop(struct nfp_app *app) 1437 { 1438 struct nfp_flower_priv *priv = app->priv; 1439 struct nfp_ipv4_addr_entry *ip_entry; 1440 struct list_head *ptr, *storage; 1441 1442 unregister_netevent_notifier(&priv->tun.neigh_nb); 1443 1444 ida_destroy(&priv->tun.mac_off_ids); 1445 1446 /* Free any memory that may be occupied by ipv4 list. */ 1447 list_for_each_safe(ptr, storage, &priv->tun.ipv4_off_list) { 1448 ip_entry = list_entry(ptr, struct nfp_ipv4_addr_entry, list); 1449 list_del(&ip_entry->list); 1450 kfree(ip_entry); 1451 } 1452 1453 mutex_destroy(&priv->tun.ipv6_off_lock); 1454 1455 /* Destroy rhash. Entries should be cleaned on netdev notifier unreg. */ 1456 rhashtable_free_and_destroy(&priv->tun.offloaded_macs, 1457 nfp_check_rhashtable_empty, NULL); 1458 1459 nfp_tun_cleanup_nn_entries(app); 1460 } 1461