1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 2 /* Copyright (c) 2019-2021 Marvell International Ltd. All rights reserved */ 3 4 #include <linux/kernel.h> 5 #include <linux/types.h> 6 #include <linux/inetdevice.h> 7 #include <net/inet_dscp.h> 8 #include <net/switchdev.h> 9 #include <linux/rhashtable.h> 10 11 #include "prestera.h" 12 #include "prestera_router_hw.h" 13 14 struct prestera_kern_fib_cache_key { 15 struct prestera_ip_addr addr; 16 u32 prefix_len; 17 u32 kern_tb_id; /* tb_id from kernel (not fixed) */ 18 }; 19 20 /* Subscribing on neighbours in kernel */ 21 struct prestera_kern_fib_cache { 22 struct prestera_kern_fib_cache_key key; 23 struct { 24 struct prestera_fib_key fib_key; 25 enum prestera_fib_type fib_type; 26 } lpm_info; /* hold prepared lpm info */ 27 /* Indicate if route is not overlapped by another table */ 28 struct rhash_head ht_node; /* node of prestera_router */ 29 struct fib_info *fi; 30 dscp_t kern_dscp; 31 u8 kern_type; 32 bool reachable; 33 }; 34 35 static const struct rhashtable_params __prestera_kern_fib_cache_ht_params = { 36 .key_offset = offsetof(struct prestera_kern_fib_cache, key), 37 .head_offset = offsetof(struct prestera_kern_fib_cache, ht_node), 38 .key_len = sizeof(struct prestera_kern_fib_cache_key), 39 .automatic_shrinking = true, 40 }; 41 42 /* This util to be used, to convert kernel rules for default vr in hw_vr */ 43 static u32 prestera_fix_tb_id(u32 tb_id) 44 { 45 if (tb_id == RT_TABLE_UNSPEC || 46 tb_id == RT_TABLE_LOCAL || 47 tb_id == RT_TABLE_DEFAULT) 48 tb_id = RT_TABLE_MAIN; 49 50 return tb_id; 51 } 52 53 static void 54 prestera_util_fen_info2fib_cache_key(struct fib_entry_notifier_info *fen_info, 55 struct prestera_kern_fib_cache_key *key) 56 { 57 memset(key, 0, sizeof(*key)); 58 key->addr.u.ipv4 = cpu_to_be32(fen_info->dst); 59 key->prefix_len = fen_info->dst_len; 60 key->kern_tb_id = fen_info->tb_id; 61 } 62 63 static struct prestera_kern_fib_cache * 64 prestera_kern_fib_cache_find(struct prestera_switch *sw, 65 struct prestera_kern_fib_cache_key *key) 66 { 67 struct prestera_kern_fib_cache *fib_cache; 68 69 fib_cache = 70 rhashtable_lookup_fast(&sw->router->kern_fib_cache_ht, key, 71 __prestera_kern_fib_cache_ht_params); 72 return fib_cache; 73 } 74 75 static void 76 prestera_kern_fib_cache_destroy(struct prestera_switch *sw, 77 struct prestera_kern_fib_cache *fib_cache) 78 { 79 fib_info_put(fib_cache->fi); 80 rhashtable_remove_fast(&sw->router->kern_fib_cache_ht, 81 &fib_cache->ht_node, 82 __prestera_kern_fib_cache_ht_params); 83 kfree(fib_cache); 84 } 85 86 /* Operations on fi (offload, etc) must be wrapped in utils. 87 * This function just create storage. 88 */ 89 static struct prestera_kern_fib_cache * 90 prestera_kern_fib_cache_create(struct prestera_switch *sw, 91 struct prestera_kern_fib_cache_key *key, 92 struct fib_info *fi, dscp_t dscp, u8 type) 93 { 94 struct prestera_kern_fib_cache *fib_cache; 95 int err; 96 97 fib_cache = kzalloc(sizeof(*fib_cache), GFP_KERNEL); 98 if (!fib_cache) 99 goto err_kzalloc; 100 101 memcpy(&fib_cache->key, key, sizeof(*key)); 102 fib_info_hold(fi); 103 fib_cache->fi = fi; 104 fib_cache->kern_dscp = dscp; 105 fib_cache->kern_type = type; 106 107 err = rhashtable_insert_fast(&sw->router->kern_fib_cache_ht, 108 &fib_cache->ht_node, 109 __prestera_kern_fib_cache_ht_params); 110 if (err) 111 goto err_ht_insert; 112 113 return fib_cache; 114 115 err_ht_insert: 116 fib_info_put(fi); 117 kfree(fib_cache); 118 err_kzalloc: 119 return NULL; 120 } 121 122 static void 123 __prestera_k_arb_fib_lpm_offload_set(struct prestera_switch *sw, 124 struct prestera_kern_fib_cache *fc, 125 bool fail, bool offload, bool trap) 126 { 127 struct fib_rt_info fri; 128 129 if (fc->key.addr.v != PRESTERA_IPV4) 130 return; 131 132 fri.fi = fc->fi; 133 fri.tb_id = fc->key.kern_tb_id; 134 fri.dst = fc->key.addr.u.ipv4; 135 fri.dst_len = fc->key.prefix_len; 136 fri.dscp = fc->kern_dscp; 137 fri.type = fc->kern_type; 138 /* flags begin */ 139 fri.offload = offload; 140 fri.trap = trap; 141 fri.offload_failed = fail; 142 /* flags end */ 143 fib_alias_hw_flags_set(&init_net, &fri); 144 } 145 146 static int 147 __prestera_pr_k_arb_fc_lpm_info_calc(struct prestera_switch *sw, 148 struct prestera_kern_fib_cache *fc) 149 { 150 memset(&fc->lpm_info, 0, sizeof(fc->lpm_info)); 151 152 switch (fc->fi->fib_type) { 153 case RTN_UNICAST: 154 fc->lpm_info.fib_type = PRESTERA_FIB_TYPE_TRAP; 155 break; 156 /* Unsupported. Leave it for kernel: */ 157 case RTN_BROADCAST: 158 case RTN_MULTICAST: 159 /* Routes we must trap by design: */ 160 case RTN_LOCAL: 161 case RTN_UNREACHABLE: 162 case RTN_PROHIBIT: 163 fc->lpm_info.fib_type = PRESTERA_FIB_TYPE_TRAP; 164 break; 165 case RTN_BLACKHOLE: 166 fc->lpm_info.fib_type = PRESTERA_FIB_TYPE_DROP; 167 break; 168 default: 169 dev_err(sw->dev->dev, "Unsupported fib_type"); 170 return -EOPNOTSUPP; 171 } 172 173 fc->lpm_info.fib_key.addr = fc->key.addr; 174 fc->lpm_info.fib_key.prefix_len = fc->key.prefix_len; 175 fc->lpm_info.fib_key.tb_id = prestera_fix_tb_id(fc->key.kern_tb_id); 176 177 return 0; 178 } 179 180 static int __prestera_k_arb_f_lpm_set(struct prestera_switch *sw, 181 struct prestera_kern_fib_cache *fc, 182 bool enabled) 183 { 184 struct prestera_fib_node *fib_node; 185 186 fib_node = prestera_fib_node_find(sw, &fc->lpm_info.fib_key); 187 if (fib_node) 188 prestera_fib_node_destroy(sw, fib_node); 189 190 if (!enabled) 191 return 0; 192 193 fib_node = prestera_fib_node_create(sw, &fc->lpm_info.fib_key, 194 fc->lpm_info.fib_type); 195 196 if (!fib_node) { 197 dev_err(sw->dev->dev, "fib_node=NULL %pI4n/%d kern_tb_id = %d", 198 &fc->key.addr.u.ipv4, fc->key.prefix_len, 199 fc->key.kern_tb_id); 200 return -ENOENT; 201 } 202 203 return 0; 204 } 205 206 static int __prestera_k_arb_fc_apply(struct prestera_switch *sw, 207 struct prestera_kern_fib_cache *fc) 208 { 209 int err; 210 211 err = __prestera_pr_k_arb_fc_lpm_info_calc(sw, fc); 212 if (err) 213 return err; 214 215 err = __prestera_k_arb_f_lpm_set(sw, fc, fc->reachable); 216 if (err) { 217 __prestera_k_arb_fib_lpm_offload_set(sw, fc, 218 true, false, false); 219 return err; 220 } 221 222 switch (fc->lpm_info.fib_type) { 223 case PRESTERA_FIB_TYPE_TRAP: 224 __prestera_k_arb_fib_lpm_offload_set(sw, fc, false, 225 false, fc->reachable); 226 break; 227 case PRESTERA_FIB_TYPE_DROP: 228 __prestera_k_arb_fib_lpm_offload_set(sw, fc, false, true, 229 fc->reachable); 230 break; 231 case PRESTERA_FIB_TYPE_INVALID: 232 break; 233 } 234 235 return 0; 236 } 237 238 static struct prestera_kern_fib_cache * 239 __prestera_k_arb_util_fib_overlaps(struct prestera_switch *sw, 240 struct prestera_kern_fib_cache *fc) 241 { 242 struct prestera_kern_fib_cache_key fc_key; 243 struct prestera_kern_fib_cache *rfc; 244 245 /* TODO: parse kernel rules */ 246 rfc = NULL; 247 if (fc->key.kern_tb_id == RT_TABLE_LOCAL) { 248 memcpy(&fc_key, &fc->key, sizeof(fc_key)); 249 fc_key.kern_tb_id = RT_TABLE_MAIN; 250 rfc = prestera_kern_fib_cache_find(sw, &fc_key); 251 } 252 253 return rfc; 254 } 255 256 static struct prestera_kern_fib_cache * 257 __prestera_k_arb_util_fib_overlapped(struct prestera_switch *sw, 258 struct prestera_kern_fib_cache *fc) 259 { 260 struct prestera_kern_fib_cache_key fc_key; 261 struct prestera_kern_fib_cache *rfc; 262 263 /* TODO: parse kernel rules */ 264 rfc = NULL; 265 if (fc->key.kern_tb_id == RT_TABLE_MAIN) { 266 memcpy(&fc_key, &fc->key, sizeof(fc_key)); 267 fc_key.kern_tb_id = RT_TABLE_LOCAL; 268 rfc = prestera_kern_fib_cache_find(sw, &fc_key); 269 } 270 271 return rfc; 272 } 273 274 static int 275 prestera_k_arb_fib_evt(struct prestera_switch *sw, 276 bool replace, /* replace or del */ 277 struct fib_entry_notifier_info *fen_info) 278 { 279 struct prestera_kern_fib_cache *tfib_cache, *bfib_cache; /* top/btm */ 280 struct prestera_kern_fib_cache_key fc_key; 281 struct prestera_kern_fib_cache *fib_cache; 282 int err; 283 284 prestera_util_fen_info2fib_cache_key(fen_info, &fc_key); 285 fib_cache = prestera_kern_fib_cache_find(sw, &fc_key); 286 if (fib_cache) { 287 fib_cache->reachable = false; 288 err = __prestera_k_arb_fc_apply(sw, fib_cache); 289 if (err) 290 dev_err(sw->dev->dev, 291 "Applying destroyed fib_cache failed"); 292 293 bfib_cache = __prestera_k_arb_util_fib_overlaps(sw, fib_cache); 294 tfib_cache = __prestera_k_arb_util_fib_overlapped(sw, fib_cache); 295 if (!tfib_cache && bfib_cache) { 296 bfib_cache->reachable = true; 297 err = __prestera_k_arb_fc_apply(sw, bfib_cache); 298 if (err) 299 dev_err(sw->dev->dev, 300 "Applying fib_cache btm failed"); 301 } 302 303 prestera_kern_fib_cache_destroy(sw, fib_cache); 304 } 305 306 if (replace) { 307 fib_cache = prestera_kern_fib_cache_create(sw, &fc_key, 308 fen_info->fi, 309 fen_info->dscp, 310 fen_info->type); 311 if (!fib_cache) { 312 dev_err(sw->dev->dev, "fib_cache == NULL"); 313 return -ENOENT; 314 } 315 316 bfib_cache = __prestera_k_arb_util_fib_overlaps(sw, fib_cache); 317 tfib_cache = __prestera_k_arb_util_fib_overlapped(sw, fib_cache); 318 if (!tfib_cache) 319 fib_cache->reachable = true; 320 321 if (bfib_cache) { 322 bfib_cache->reachable = false; 323 err = __prestera_k_arb_fc_apply(sw, bfib_cache); 324 if (err) 325 dev_err(sw->dev->dev, 326 "Applying fib_cache btm failed"); 327 } 328 329 err = __prestera_k_arb_fc_apply(sw, fib_cache); 330 if (err) 331 dev_err(sw->dev->dev, "Applying fib_cache failed"); 332 } 333 334 return 0; 335 } 336 337 static int __prestera_inetaddr_port_event(struct net_device *port_dev, 338 unsigned long event, 339 struct netlink_ext_ack *extack) 340 { 341 struct prestera_port *port = netdev_priv(port_dev); 342 struct prestera_rif_entry_key re_key = {}; 343 struct prestera_rif_entry *re; 344 u32 kern_tb_id; 345 int err; 346 347 err = prestera_is_valid_mac_addr(port, port_dev->dev_addr); 348 if (err) { 349 NL_SET_ERR_MSG_MOD(extack, "RIF MAC must have the same prefix"); 350 return err; 351 } 352 353 kern_tb_id = l3mdev_fib_table(port_dev); 354 re_key.iface.type = PRESTERA_IF_PORT_E; 355 re_key.iface.dev_port.hw_dev_num = port->dev_id; 356 re_key.iface.dev_port.port_num = port->hw_id; 357 re = prestera_rif_entry_find(port->sw, &re_key); 358 359 switch (event) { 360 case NETDEV_UP: 361 if (re) { 362 NL_SET_ERR_MSG_MOD(extack, "RIF already exist"); 363 return -EEXIST; 364 } 365 re = prestera_rif_entry_create(port->sw, &re_key, 366 prestera_fix_tb_id(kern_tb_id), 367 port_dev->dev_addr); 368 if (!re) { 369 NL_SET_ERR_MSG_MOD(extack, "Can't create RIF"); 370 return -EINVAL; 371 } 372 dev_hold(port_dev); 373 break; 374 case NETDEV_DOWN: 375 if (!re) { 376 NL_SET_ERR_MSG_MOD(extack, "Can't find RIF"); 377 return -EEXIST; 378 } 379 prestera_rif_entry_destroy(port->sw, re); 380 dev_put(port_dev); 381 break; 382 } 383 384 return 0; 385 } 386 387 static int __prestera_inetaddr_event(struct prestera_switch *sw, 388 struct net_device *dev, 389 unsigned long event, 390 struct netlink_ext_ack *extack) 391 { 392 if (!prestera_netdev_check(dev) || netif_is_any_bridge_port(dev) || 393 netif_is_lag_port(dev)) 394 return 0; 395 396 return __prestera_inetaddr_port_event(dev, event, extack); 397 } 398 399 static int __prestera_inetaddr_cb(struct notifier_block *nb, 400 unsigned long event, void *ptr) 401 { 402 struct in_ifaddr *ifa = (struct in_ifaddr *)ptr; 403 struct net_device *dev = ifa->ifa_dev->dev; 404 struct prestera_router *router = container_of(nb, 405 struct prestera_router, 406 inetaddr_nb); 407 struct in_device *idev; 408 int err = 0; 409 410 if (event != NETDEV_DOWN) 411 goto out; 412 413 /* Ignore if this is not latest address */ 414 idev = __in_dev_get_rtnl(dev); 415 if (idev && idev->ifa_list) 416 goto out; 417 418 err = __prestera_inetaddr_event(router->sw, dev, event, NULL); 419 out: 420 return notifier_from_errno(err); 421 } 422 423 static int __prestera_inetaddr_valid_cb(struct notifier_block *nb, 424 unsigned long event, void *ptr) 425 { 426 struct in_validator_info *ivi = (struct in_validator_info *)ptr; 427 struct net_device *dev = ivi->ivi_dev->dev; 428 struct prestera_router *router = container_of(nb, 429 struct prestera_router, 430 inetaddr_valid_nb); 431 struct in_device *idev; 432 int err = 0; 433 434 if (event != NETDEV_UP) 435 goto out; 436 437 /* Ignore if this is not first address */ 438 idev = __in_dev_get_rtnl(dev); 439 if (idev && idev->ifa_list) 440 goto out; 441 442 if (ipv4_is_multicast(ivi->ivi_addr)) { 443 NL_SET_ERR_MSG_MOD(ivi->extack, 444 "Multicast addr on RIF is not supported"); 445 err = -EINVAL; 446 goto out; 447 } 448 449 err = __prestera_inetaddr_event(router->sw, dev, event, ivi->extack); 450 out: 451 return notifier_from_errno(err); 452 } 453 454 struct prestera_fib_event_work { 455 struct work_struct work; 456 struct prestera_switch *sw; 457 struct fib_entry_notifier_info fen_info; 458 unsigned long event; 459 }; 460 461 static void __prestera_router_fib_event_work(struct work_struct *work) 462 { 463 struct prestera_fib_event_work *fib_work = 464 container_of(work, struct prestera_fib_event_work, work); 465 struct prestera_switch *sw = fib_work->sw; 466 int err; 467 468 rtnl_lock(); 469 470 switch (fib_work->event) { 471 case FIB_EVENT_ENTRY_REPLACE: 472 err = prestera_k_arb_fib_evt(sw, true, &fib_work->fen_info); 473 if (err) 474 goto err_out; 475 476 break; 477 case FIB_EVENT_ENTRY_DEL: 478 err = prestera_k_arb_fib_evt(sw, false, &fib_work->fen_info); 479 if (err) 480 goto err_out; 481 482 break; 483 } 484 485 goto out; 486 487 err_out: 488 dev_err(sw->dev->dev, "Error when processing %pI4h/%d", 489 &fib_work->fen_info.dst, 490 fib_work->fen_info.dst_len); 491 out: 492 fib_info_put(fib_work->fen_info.fi); 493 rtnl_unlock(); 494 kfree(fib_work); 495 } 496 497 /* Called with rcu_read_lock() */ 498 static int __prestera_router_fib_event(struct notifier_block *nb, 499 unsigned long event, void *ptr) 500 { 501 struct prestera_fib_event_work *fib_work; 502 struct fib_entry_notifier_info *fen_info; 503 struct fib_notifier_info *info = ptr; 504 struct prestera_router *router; 505 506 if (info->family != AF_INET) 507 return NOTIFY_DONE; 508 509 router = container_of(nb, struct prestera_router, fib_nb); 510 511 switch (event) { 512 case FIB_EVENT_ENTRY_REPLACE: 513 case FIB_EVENT_ENTRY_DEL: 514 fen_info = container_of(info, struct fib_entry_notifier_info, 515 info); 516 if (!fen_info->fi) 517 return NOTIFY_DONE; 518 519 fib_work = kzalloc(sizeof(*fib_work), GFP_ATOMIC); 520 if (WARN_ON(!fib_work)) 521 return NOTIFY_BAD; 522 523 fib_info_hold(fen_info->fi); 524 fib_work->fen_info = *fen_info; 525 fib_work->event = event; 526 fib_work->sw = router->sw; 527 INIT_WORK(&fib_work->work, __prestera_router_fib_event_work); 528 prestera_queue_work(&fib_work->work); 529 break; 530 default: 531 return NOTIFY_DONE; 532 } 533 534 return NOTIFY_DONE; 535 } 536 537 int prestera_router_init(struct prestera_switch *sw) 538 { 539 struct prestera_router *router; 540 int err; 541 542 router = kzalloc(sizeof(*sw->router), GFP_KERNEL); 543 if (!router) 544 return -ENOMEM; 545 546 sw->router = router; 547 router->sw = sw; 548 549 err = prestera_router_hw_init(sw); 550 if (err) 551 goto err_router_lib_init; 552 553 err = rhashtable_init(&router->kern_fib_cache_ht, 554 &__prestera_kern_fib_cache_ht_params); 555 if (err) 556 goto err_kern_fib_cache_ht_init; 557 558 router->inetaddr_valid_nb.notifier_call = __prestera_inetaddr_valid_cb; 559 err = register_inetaddr_validator_notifier(&router->inetaddr_valid_nb); 560 if (err) 561 goto err_register_inetaddr_validator_notifier; 562 563 router->inetaddr_nb.notifier_call = __prestera_inetaddr_cb; 564 err = register_inetaddr_notifier(&router->inetaddr_nb); 565 if (err) 566 goto err_register_inetaddr_notifier; 567 568 router->fib_nb.notifier_call = __prestera_router_fib_event; 569 err = register_fib_notifier(&init_net, &router->fib_nb, 570 /* TODO: flush fib entries */ NULL, NULL); 571 if (err) 572 goto err_register_fib_notifier; 573 574 return 0; 575 576 err_register_fib_notifier: 577 unregister_inetaddr_notifier(&router->inetaddr_nb); 578 err_register_inetaddr_notifier: 579 unregister_inetaddr_validator_notifier(&router->inetaddr_valid_nb); 580 err_register_inetaddr_validator_notifier: 581 rhashtable_destroy(&router->kern_fib_cache_ht); 582 err_kern_fib_cache_ht_init: 583 prestera_router_hw_fini(sw); 584 err_router_lib_init: 585 kfree(sw->router); 586 return err; 587 } 588 589 void prestera_router_fini(struct prestera_switch *sw) 590 { 591 unregister_fib_notifier(&init_net, &sw->router->fib_nb); 592 unregister_inetaddr_notifier(&sw->router->inetaddr_nb); 593 unregister_inetaddr_validator_notifier(&sw->router->inetaddr_valid_nb); 594 rhashtable_destroy(&sw->router->kern_fib_cache_ht); 595 prestera_router_hw_fini(sw); 596 kfree(sw->router); 597 sw->router = NULL; 598 } 599