drivers/net/ethernet/marvell/prestera/prestera_router.c

   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 #include <net/nexthop.h>
  11 #include <net/arp.h>
  12 #include <linux/if_vlan.h>
  13 #include <linux/if_macvlan.h>
  14 #include <net/netevent.h>
  15
  16 #include "prestera.h"
  17 #include "prestera_router_hw.h"
  18
  19 #define PRESTERA_IMPLICITY_RESOLVE_DEAD_NEIGH
  20 #define PRESTERA_NH_PROBE_INTERVAL 5000 /* ms */
  21
  22 struct prestera_kern_neigh_cache_key {
  23         struct prestera_ip_addr addr;
  24         struct net_device *dev;
  25 };
  26
  27 struct prestera_kern_neigh_cache {
  28         struct prestera_kern_neigh_cache_key key;
  29         struct rhash_head ht_node;
  30         struct list_head kern_fib_cache_list;
  31         /* Hold prepared nh_neigh info if is in_kernel */
  32         struct prestera_neigh_info nh_neigh_info;
  33         /* Indicate if neighbour is reachable by direct route */
  34         bool reachable;
  35         /* Lock cache if neigh is present in kernel */
  36         bool in_kernel;
  37 };
  38
  39 struct prestera_kern_fib_cache_key {
  40         struct prestera_ip_addr addr;
  41         u32 prefix_len;
  42         u32 kern_tb_id; /* tb_id from kernel (not fixed) */
  43 };
  44
  45 /* Subscribing on neighbours in kernel */
  46 struct prestera_kern_fib_cache {
  47         struct prestera_kern_fib_cache_key key;
  48         struct {
  49                 struct prestera_fib_key fib_key;
  50                 enum prestera_fib_type fib_type;
  51                 struct prestera_nexthop_group_key nh_grp_key;
  52         } lpm_info; /* hold prepared lpm info */
  53         /* Indicate if route is not overlapped by another table */
  54         struct rhash_head ht_node; /* node of prestera_router */
  55         struct prestera_kern_neigh_cache_head {
  56                 struct prestera_kern_fib_cache *this;
  57                 struct list_head head;
  58                 struct prestera_kern_neigh_cache *n_cache;
  59         } kern_neigh_cache_head[PRESTERA_NHGR_SIZE_MAX];
  60         union {
  61                 struct fib_notifier_info info; /* point to any of 4/6 */
  62                 struct fib_entry_notifier_info fen4_info;
  63         };
  64         bool reachable;
  65 };
  66
  67 static const struct rhashtable_params __prestera_kern_neigh_cache_ht_params = {
  68         .key_offset  = offsetof(struct prestera_kern_neigh_cache, key),
  69         .head_offset = offsetof(struct prestera_kern_neigh_cache, ht_node),
  70         .key_len     = sizeof(struct prestera_kern_neigh_cache_key),
  71         .automatic_shrinking = true,
  72 };
  73
  74 static const struct rhashtable_params __prestera_kern_fib_cache_ht_params = {
  75         .key_offset  = offsetof(struct prestera_kern_fib_cache, key),
  76         .head_offset = offsetof(struct prestera_kern_fib_cache, ht_node),
  77         .key_len     = sizeof(struct prestera_kern_fib_cache_key),
  78         .automatic_shrinking = true,
  79 };
  80
  81 /* This util to be used, to convert kernel rules for default vr in hw_vr */
  82 static u32 prestera_fix_tb_id(u32 tb_id)
  83 {
  84         if (tb_id == RT_TABLE_UNSPEC ||
  85             tb_id == RT_TABLE_LOCAL ||
  86             tb_id == RT_TABLE_DEFAULT)
  87                 tb_id = RT_TABLE_MAIN;
  88
  89         return tb_id;
  90 }
  91
  92 static void
  93 prestera_util_fen_info2fib_cache_key(struct fib_notifier_info *info,
  94                                      struct prestera_kern_fib_cache_key *key)
  95 {
  96         struct fib_entry_notifier_info *fen_info =
  97                 container_of(info, struct fib_entry_notifier_info, info);
  98
  99         memset(key, 0, sizeof(*key));
 100         key->addr.v = PRESTERA_IPV4;
 101         key->addr.u.ipv4 = cpu_to_be32(fen_info->dst);
 102         key->prefix_len = fen_info->dst_len;
 103         key->kern_tb_id = fen_info->tb_id;
 104 }
 105
 106 static int prestera_util_nhc2nc_key(struct prestera_switch *sw,
 107                                     struct fib_nh_common *nhc,
 108                                     struct prestera_kern_neigh_cache_key *nk)
 109 {
 110         memset(nk, 0, sizeof(*nk));
 111         if (nhc->nhc_gw_family == AF_INET) {
 112                 nk->addr.v = PRESTERA_IPV4;
 113                 nk->addr.u.ipv4 = nhc->nhc_gw.ipv4;
 114         } else {
 115                 nk->addr.v = PRESTERA_IPV6;
 116                 nk->addr.u.ipv6 = nhc->nhc_gw.ipv6;
 117         }
 118
 119         nk->dev = nhc->nhc_dev;
 120         return 0;
 121 }
 122
 123 static void
 124 prestera_util_nc_key2nh_key(struct prestera_kern_neigh_cache_key *ck,
 125                             struct prestera_nh_neigh_key *nk)
 126 {
 127         memset(nk, 0, sizeof(*nk));
 128         nk->addr = ck->addr;
 129         nk->rif = (void *)ck->dev;
 130 }
 131
 132 static bool
 133 prestera_util_nhc_eq_n_cache_key(struct prestera_switch *sw,
 134                                  struct fib_nh_common *nhc,
 135                                  struct prestera_kern_neigh_cache_key *nk)
 136 {
 137         struct prestera_kern_neigh_cache_key tk;
 138         int err;
 139
 140         err = prestera_util_nhc2nc_key(sw, nhc, &tk);
 141         if (err)
 142                 return false;
 143
 144         if (memcmp(&tk, nk, sizeof(tk)))
 145                 return false;
 146
 147         return true;
 148 }
 149
 150 static int
 151 prestera_util_neigh2nc_key(struct prestera_switch *sw, struct neighbour *n,
 152                            struct prestera_kern_neigh_cache_key *key)
 153 {
 154         memset(key, 0, sizeof(*key));
 155         if (n->tbl->family == AF_INET) {
 156                 key->addr.v = PRESTERA_IPV4;
 157                 key->addr.u.ipv4 = *(__be32 *)n->primary_key;
 158         } else {
 159                 return -ENOENT;
 160         }
 161
 162         key->dev = n->dev;
 163
 164         return 0;
 165 }
 166
 167 static bool __prestera_fi_is_direct(struct fib_info *fi)
 168 {
 169         struct fib_nh_common *fib_nhc;
 170
 171         if (fib_info_num_path(fi) == 1) {
 172                 fib_nhc = fib_info_nhc(fi, 0);
 173                 if (fib_nhc->nhc_gw_family == AF_UNSPEC)
 174                         return true;
 175         }
 176
 177         return false;
 178 }
 179
 180 static bool prestera_fi_is_direct(struct fib_info *fi)
 181 {
 182         if (fi->fib_type != RTN_UNICAST)
 183                 return false;
 184
 185         return __prestera_fi_is_direct(fi);
 186 }
 187
 188 static bool prestera_fi_is_nh(struct fib_info *fi)
 189 {
 190         if (fi->fib_type != RTN_UNICAST)
 191                 return false;
 192
 193         return !__prestera_fi_is_direct(fi);
 194 }
 195
 196 static bool __prestera_fi6_is_direct(struct fib6_info *fi)
 197 {
 198         if (!fi->fib6_nh->nh_common.nhc_gw_family)
 199                 return true;
 200
 201         return false;
 202 }
 203
 204 static bool prestera_fi6_is_direct(struct fib6_info *fi)
 205 {
 206         if (fi->fib6_type != RTN_UNICAST)
 207                 return false;
 208
 209         return __prestera_fi6_is_direct(fi);
 210 }
 211
 212 static bool prestera_fi6_is_nh(struct fib6_info *fi)
 213 {
 214         if (fi->fib6_type != RTN_UNICAST)
 215                 return false;
 216
 217         return !__prestera_fi6_is_direct(fi);
 218 }
 219
 220 static bool prestera_fib_info_is_direct(struct fib_notifier_info *info)
 221 {
 222         struct fib6_entry_notifier_info *fen6_info =
 223                 container_of(info, struct fib6_entry_notifier_info, info);
 224         struct fib_entry_notifier_info *fen_info =
 225                 container_of(info, struct fib_entry_notifier_info, info);
 226
 227         if (info->family == AF_INET)
 228                 return prestera_fi_is_direct(fen_info->fi);
 229         else
 230                 return prestera_fi6_is_direct(fen6_info->rt);
 231 }
 232
 233 static bool prestera_fib_info_is_nh(struct fib_notifier_info *info)
 234 {
 235         struct fib6_entry_notifier_info *fen6_info =
 236                 container_of(info, struct fib6_entry_notifier_info, info);
 237         struct fib_entry_notifier_info *fen_info =
 238                 container_of(info, struct fib_entry_notifier_info, info);
 239
 240         if (info->family == AF_INET)
 241                 return prestera_fi_is_nh(fen_info->fi);
 242         else
 243                 return prestera_fi6_is_nh(fen6_info->rt);
 244 }
 245
 246 /* must be called with rcu_read_lock() */
 247 static int prestera_util_kern_get_route(struct fib_result *res, u32 tb_id,
 248                                         __be32 *addr)
 249 {
 250         struct flowi4 fl4;
 251
 252         /* TODO: walkthrough appropriate tables in kernel
 253          * to know if the same prefix exists in several tables
 254          */
 255         memset(&fl4, 0, sizeof(fl4));
 256         fl4.daddr = *addr;
 257         return fib_lookup(&init_net, &fl4, res, 0 /* FIB_LOOKUP_NOREF */);
 258 }
 259
 260 static bool
 261 __prestera_util_kern_n_is_reachable_v4(u32 tb_id, __be32 *addr,
 262                                        struct net_device *dev)
 263 {
 264         struct fib_nh_common *fib_nhc;
 265         struct fib_result res;
 266         bool reachable;
 267
 268         reachable = false;
 269
 270         if (!prestera_util_kern_get_route(&res, tb_id, addr))
 271                 if (prestera_fi_is_direct(res.fi)) {
 272                         fib_nhc = fib_info_nhc(res.fi, 0);
 273                         if (dev == fib_nhc->nhc_dev)
 274                                 reachable = true;
 275                 }
 276
 277         return reachable;
 278 }
 279
 280 /* Check if neigh route is reachable */
 281 static bool
 282 prestera_util_kern_n_is_reachable(u32 tb_id,
 283                                   struct prestera_ip_addr *addr,
 284                                   struct net_device *dev)
 285 {
 286         if (addr->v == PRESTERA_IPV4)
 287                 return __prestera_util_kern_n_is_reachable_v4(tb_id,
 288                                                               &addr->u.ipv4,
 289                                                               dev);
 290         else
 291                 return false;
 292 }
 293
 294 static void prestera_util_kern_set_neigh_offload(struct neighbour *n,
 295                                                  bool offloaded)
 296 {
 297         if (offloaded)
 298                 n->flags |= NTF_OFFLOADED;
 299         else
 300                 n->flags &= ~NTF_OFFLOADED;
 301 }
 302
 303 static void
 304 prestera_util_kern_set_nh_offload(struct fib_nh_common *nhc, bool offloaded, bool trap)
 305 {
 306                 if (offloaded)
 307                         nhc->nhc_flags |= RTNH_F_OFFLOAD;
 308                 else
 309                         nhc->nhc_flags &= ~RTNH_F_OFFLOAD;
 310
 311                 if (trap)
 312                         nhc->nhc_flags |= RTNH_F_TRAP;
 313                 else
 314                         nhc->nhc_flags &= ~RTNH_F_TRAP;
 315 }
 316
 317 static struct fib_nh_common *
 318 prestera_kern_fib_info_nhc(struct fib_notifier_info *info, int n)
 319 {
 320         struct fib6_entry_notifier_info *fen6_info;
 321         struct fib_entry_notifier_info *fen4_info;
 322         struct fib6_info *iter;
 323
 324         if (info->family == AF_INET) {
 325                 fen4_info = container_of(info, struct fib_entry_notifier_info,
 326                                          info);
 327                 return fib_info_nhc(fen4_info->fi, n);
 328         } else if (info->family == AF_INET6) {
 329                 fen6_info = container_of(info, struct fib6_entry_notifier_info,
 330                                          info);
 331                 if (!n)
 332                         return &fen6_info->rt->fib6_nh->nh_common;
 333
 334                 list_for_each_entry(iter, &fen6_info->rt->fib6_siblings,
 335                                     fib6_siblings) {
 336                         if (!--n)
 337                                 return &iter->fib6_nh->nh_common;
 338                 }
 339         }
 340
 341         /* if family is incorrect - than upper functions has BUG */
 342         /* if doesn't find requested index - there is alsi bug, because
 343          * valid index must be produced by nhs, which checks list length
 344          */
 345         WARN(1, "Invalid parameters passed to %s n=%d i=%p",
 346              __func__, n, info);
 347         return NULL;
 348 }
 349
 350 static int prestera_kern_fib_info_nhs(struct fib_notifier_info *info)
 351 {
 352         struct fib6_entry_notifier_info *fen6_info;
 353         struct fib_entry_notifier_info *fen4_info;
 354
 355         if (info->family == AF_INET) {
 356                 fen4_info = container_of(info, struct fib_entry_notifier_info,
 357                                          info);
 358                 return fib_info_num_path(fen4_info->fi);
 359         } else if (info->family == AF_INET6) {
 360                 fen6_info = container_of(info, struct fib6_entry_notifier_info,
 361                                          info);
 362                 return fen6_info->rt->fib6_nsiblings + 1;
 363         }
 364
 365         return 0;
 366 }
 367
 368 static unsigned char
 369 prestera_kern_fib_info_type(struct fib_notifier_info *info)
 370 {
 371         struct fib6_entry_notifier_info *fen6_info;
 372         struct fib_entry_notifier_info *fen4_info;
 373
 374         if (info->family == AF_INET) {
 375                 fen4_info = container_of(info, struct fib_entry_notifier_info,
 376                                          info);
 377                 return fen4_info->fi->fib_type;
 378         } else if (info->family == AF_INET6) {
 379                 fen6_info = container_of(info, struct fib6_entry_notifier_info,
 380                                          info);
 381                 /* TODO: ECMP in ipv6 is several routes.
 382                  * Every route has single nh.
 383                  */
 384                 return fen6_info->rt->fib6_type;
 385         }
 386
 387         return RTN_UNSPEC;
 388 }
 389
 390 /* Decided, that uc_nh route with key==nh is obviously neighbour route */
 391 static bool
 392 prestera_fib_node_util_is_neighbour(struct prestera_fib_node *fib_node)
 393 {
 394         if (fib_node->info.type != PRESTERA_FIB_TYPE_UC_NH)
 395                 return false;
 396
 397         if (fib_node->info.nh_grp->nh_neigh_head[1].neigh)
 398                 return false;
 399
 400         if (!fib_node->info.nh_grp->nh_neigh_head[0].neigh)
 401                 return false;
 402
 403         if (memcmp(&fib_node->info.nh_grp->nh_neigh_head[0].neigh->key.addr,
 404                    &fib_node->key.addr, sizeof(struct prestera_ip_addr)))
 405                 return false;
 406
 407         return true;
 408 }
 409
 410 static int prestera_dev_if_type(const struct net_device *dev)
 411 {
 412         struct macvlan_dev *vlan;
 413
 414         if (is_vlan_dev(dev) &&
 415             netif_is_bridge_master(vlan_dev_real_dev(dev))) {
 416                 return PRESTERA_IF_VID_E;
 417         } else if (netif_is_bridge_master(dev)) {
 418                 return PRESTERA_IF_VID_E;
 419         } else if (netif_is_lag_master(dev)) {
 420                 return PRESTERA_IF_LAG_E;
 421         } else if (netif_is_macvlan(dev)) {
 422                 vlan = netdev_priv(dev);
 423                 return prestera_dev_if_type(vlan->lowerdev);
 424         } else {
 425                 return PRESTERA_IF_PORT_E;
 426         }
 427 }
 428
 429 static int
 430 prestera_neigh_iface_init(struct prestera_switch *sw,
 431                           struct prestera_iface *iface,
 432                           struct neighbour *n)
 433 {
 434         struct prestera_port *port;
 435
 436         iface->vlan_id = 0; /* TODO: vlan egress */
 437         iface->type = prestera_dev_if_type(n->dev);
 438         if (iface->type != PRESTERA_IF_PORT_E)
 439                 return -EINVAL;
 440
 441         if (!prestera_netdev_check(n->dev))
 442                 return -EINVAL;
 443
 444         port = netdev_priv(n->dev);
 445         iface->dev_port.hw_dev_num = port->dev_id;
 446         iface->dev_port.port_num = port->hw_id;
 447
 448         return 0;
 449 }
 450
 451 static struct prestera_kern_neigh_cache *
 452 prestera_kern_neigh_cache_find(struct prestera_switch *sw,
 453                                struct prestera_kern_neigh_cache_key *key)
 454 {
 455         struct prestera_kern_neigh_cache *n_cache;
 456
 457         n_cache =
 458          rhashtable_lookup_fast(&sw->router->kern_neigh_cache_ht, key,
 459                                 __prestera_kern_neigh_cache_ht_params);
 460         return n_cache;
 461 }
 462
 463 static void
 464 __prestera_kern_neigh_cache_destruct(struct prestera_switch *sw,
 465                                      struct prestera_kern_neigh_cache *n_cache)
 466 {
 467         dev_put(n_cache->key.dev);
 468 }
 469
 470 static void
 471 __prestera_kern_neigh_cache_destroy(struct prestera_switch *sw,
 472                                     struct prestera_kern_neigh_cache *n_cache)
 473 {
 474         rhashtable_remove_fast(&sw->router->kern_neigh_cache_ht,
 475                                &n_cache->ht_node,
 476                                __prestera_kern_neigh_cache_ht_params);
 477         __prestera_kern_neigh_cache_destruct(sw, n_cache);
 478         kfree(n_cache);
 479 }
 480
 481 static struct prestera_kern_neigh_cache *
 482 __prestera_kern_neigh_cache_create(struct prestera_switch *sw,
 483                                    struct prestera_kern_neigh_cache_key *key)
 484 {
 485         struct prestera_kern_neigh_cache *n_cache;
 486         int err;
 487
 488         n_cache = kzalloc(sizeof(*n_cache), GFP_KERNEL);
 489         if (!n_cache)
 490                 goto err_kzalloc;
 491
 492         memcpy(&n_cache->key, key, sizeof(*key));
 493         dev_hold(n_cache->key.dev);
 494
 495         INIT_LIST_HEAD(&n_cache->kern_fib_cache_list);
 496         err = rhashtable_insert_fast(&sw->router->kern_neigh_cache_ht,
 497                                      &n_cache->ht_node,
 498                                      __prestera_kern_neigh_cache_ht_params);
 499         if (err)
 500                 goto err_ht_insert;
 501
 502         return n_cache;
 503
 504 err_ht_insert:
 505         dev_put(n_cache->key.dev);
 506         kfree(n_cache);
 507 err_kzalloc:
 508         return NULL;
 509 }
 510
 511 static struct prestera_kern_neigh_cache *
 512 prestera_kern_neigh_cache_get(struct prestera_switch *sw,
 513                               struct prestera_kern_neigh_cache_key *key)
 514 {
 515         struct prestera_kern_neigh_cache *n_cache;
 516
 517         n_cache = prestera_kern_neigh_cache_find(sw, key);
 518         if (!n_cache)
 519                 n_cache = __prestera_kern_neigh_cache_create(sw, key);
 520
 521         return n_cache;
 522 }
 523
 524 static struct prestera_kern_neigh_cache *
 525 prestera_kern_neigh_cache_put(struct prestera_switch *sw,
 526                               struct prestera_kern_neigh_cache *n_cache)
 527 {
 528         if (!n_cache->in_kernel &&
 529             list_empty(&n_cache->kern_fib_cache_list)) {
 530                 __prestera_kern_neigh_cache_destroy(sw, n_cache);
 531                 return NULL;
 532         }
 533
 534         return n_cache;
 535 }
 536
 537 static struct prestera_kern_fib_cache *
 538 prestera_kern_fib_cache_find(struct prestera_switch *sw,
 539                              struct prestera_kern_fib_cache_key *key)
 540 {
 541         struct prestera_kern_fib_cache *fib_cache;
 542
 543         fib_cache =
 544          rhashtable_lookup_fast(&sw->router->kern_fib_cache_ht, key,
 545                                 __prestera_kern_fib_cache_ht_params);
 546         return fib_cache;
 547 }
 548
 549 static void
 550 __prestera_kern_fib_cache_destruct(struct prestera_switch *sw,
 551                                    struct prestera_kern_fib_cache *fib_cache)
 552 {
 553         struct prestera_kern_neigh_cache *n_cache;
 554         int i;
 555
 556         for (i = 0; i < PRESTERA_NHGR_SIZE_MAX; i++) {
 557                 n_cache = fib_cache->kern_neigh_cache_head[i].n_cache;
 558                 if (n_cache) {
 559                         list_del(&fib_cache->kern_neigh_cache_head[i].head);
 560                         prestera_kern_neigh_cache_put(sw, n_cache);
 561                 }
 562         }
 563
 564         fib_info_put(fib_cache->fen4_info.fi);
 565 }
 566
 567 static void
 568 prestera_kern_fib_cache_destroy(struct prestera_switch *sw,
 569                                 struct prestera_kern_fib_cache *fib_cache)
 570 {
 571         rhashtable_remove_fast(&sw->router->kern_fib_cache_ht,
 572                                &fib_cache->ht_node,
 573                                __prestera_kern_fib_cache_ht_params);
 574         __prestera_kern_fib_cache_destruct(sw, fib_cache);
 575         kfree(fib_cache);
 576 }
 577
 578 static int
 579 __prestera_kern_fib_cache_create_nhs(struct prestera_switch *sw,
 580                                      struct prestera_kern_fib_cache *fc)
 581 {
 582         struct prestera_kern_neigh_cache_key nc_key;
 583         struct prestera_kern_neigh_cache *n_cache;
 584         struct fib_nh_common *nhc;
 585         int i, nhs, err;
 586
 587         if (!prestera_fib_info_is_nh(&fc->info))
 588                 return 0;
 589
 590         nhs = prestera_kern_fib_info_nhs(&fc->info);
 591         if (nhs > PRESTERA_NHGR_SIZE_MAX)
 592                 return 0;
 593
 594         for (i = 0; i < nhs; i++) {
 595                 nhc = prestera_kern_fib_info_nhc(&fc->fen4_info.info, i);
 596                 err = prestera_util_nhc2nc_key(sw, nhc, &nc_key);
 597                 if (err)
 598                         return 0;
 599
 600                 n_cache = prestera_kern_neigh_cache_get(sw, &nc_key);
 601                 if (!n_cache)
 602                         return 0;
 603
 604                 fc->kern_neigh_cache_head[i].this = fc;
 605                 fc->kern_neigh_cache_head[i].n_cache = n_cache;
 606                 list_add(&fc->kern_neigh_cache_head[i].head,
 607                          &n_cache->kern_fib_cache_list);
 608         }
 609
 610         return 0;
 611 }
 612
 613 /* Operations on fi (offload, etc) must be wrapped in utils.
 614  * This function just create storage.
 615  */
 616 static struct prestera_kern_fib_cache *
 617 prestera_kern_fib_cache_create(struct prestera_switch *sw,
 618                                struct prestera_kern_fib_cache_key *key,
 619                                struct fib_notifier_info *info)
 620 {
 621         struct fib_entry_notifier_info *fen_info =
 622                 container_of(info, struct fib_entry_notifier_info, info);
 623         struct prestera_kern_fib_cache *fib_cache;
 624         int err;
 625
 626         fib_cache = kzalloc(sizeof(*fib_cache), GFP_KERNEL);
 627         if (!fib_cache)
 628                 goto err_kzalloc;
 629
 630         memcpy(&fib_cache->key, key, sizeof(*key));
 631         fib_info_hold(fen_info->fi);
 632         memcpy(&fib_cache->fen4_info, fen_info, sizeof(*fen_info));
 633
 634         err = rhashtable_insert_fast(&sw->router->kern_fib_cache_ht,
 635                                      &fib_cache->ht_node,
 636                                      __prestera_kern_fib_cache_ht_params);
 637         if (err)
 638                 goto err_ht_insert;
 639
 640         /* Handle nexthops */
 641         err = __prestera_kern_fib_cache_create_nhs(sw, fib_cache);
 642         if (err)
 643                 goto out; /* Not critical */
 644
 645 out:
 646         return fib_cache;
 647
 648 err_ht_insert:
 649         fib_info_put(fen_info->fi);
 650         kfree(fib_cache);
 651 err_kzalloc:
 652         return NULL;
 653 }
 654
 655 static void
 656 __prestera_k_arb_fib_nh_offload_set(struct prestera_switch *sw,
 657                                     struct prestera_kern_fib_cache *fibc,
 658                                     struct prestera_kern_neigh_cache *nc,
 659                                     bool offloaded, bool trap)
 660 {
 661         struct fib_nh_common *nhc;
 662         int i, nhs;
 663
 664         nhs = prestera_kern_fib_info_nhs(&fibc->info);
 665         for (i = 0; i < nhs; i++) {
 666                 nhc = prestera_kern_fib_info_nhc(&fibc->info, i);
 667                 if (!nc) {
 668                         prestera_util_kern_set_nh_offload(nhc, offloaded, trap);
 669                         continue;
 670                 }
 671
 672                 if (prestera_util_nhc_eq_n_cache_key(sw, nhc, &nc->key)) {
 673                         prestera_util_kern_set_nh_offload(nhc, offloaded, trap);
 674                         break;
 675                 }
 676         }
 677 }
 678
 679 static void
 680 __prestera_k_arb_n_offload_set(struct prestera_switch *sw,
 681                                struct prestera_kern_neigh_cache *nc,
 682                                bool offloaded)
 683 {
 684         struct neighbour *n;
 685
 686         n = neigh_lookup(&arp_tbl, &nc->key.addr.u.ipv4,
 687                          nc->key.dev);
 688         if (!n)
 689                 return;
 690
 691         prestera_util_kern_set_neigh_offload(n, offloaded);
 692         neigh_release(n);
 693 }
 694
 695 static void
 696 __prestera_k_arb_fib_lpm_offload_set(struct prestera_switch *sw,
 697                                      struct prestera_kern_fib_cache *fc,
 698                                      bool fail, bool offload, bool trap)
 699 {
 700         struct fib_rt_info fri;
 701
 702         switch (fc->key.addr.v) {
 703         case PRESTERA_IPV4:
 704                 fri.fi = fc->fen4_info.fi;
 705                 fri.tb_id = fc->key.kern_tb_id;
 706                 fri.dst = fc->key.addr.u.ipv4;
 707                 fri.dst_len = fc->key.prefix_len;
 708                 fri.dscp = fc->fen4_info.dscp;
 709                 fri.type = fc->fen4_info.type;
 710                 /* flags begin */
 711                 fri.offload = offload;
 712                 fri.trap = trap;
 713                 fri.offload_failed = fail;
 714                 /* flags end */
 715                 fib_alias_hw_flags_set(&init_net, &fri);
 716                 return;
 717         case PRESTERA_IPV6:
 718                 /* TODO */
 719                 return;
 720         }
 721 }
 722
 723 static void
 724 __prestera_k_arb_n_lpm_set(struct prestera_switch *sw,
 725                            struct prestera_kern_neigh_cache *n_cache,
 726                            bool enabled)
 727 {
 728         struct prestera_nexthop_group_key nh_grp_key;
 729         struct prestera_kern_fib_cache_key fc_key;
 730         struct prestera_kern_fib_cache *fib_cache;
 731         struct prestera_fib_node *fib_node;
 732         struct prestera_fib_key fib_key;
 733
 734         /* Exception for fc with prefix 32: LPM entry is already used by fib */
 735         memset(&fc_key, 0, sizeof(fc_key));
 736         fc_key.addr = n_cache->key.addr;
 737         fc_key.prefix_len = PRESTERA_IP_ADDR_PLEN(n_cache->key.addr.v);
 738         /* But better to use tb_id of route, which pointed to this neighbour. */
 739         /* We take it from rif, because rif inconsistent.
 740          * Must be separated in_rif and out_rif.
 741          * Also note: for each fib pointed to this neigh should be separated
 742          *            neigh lpm entry (for each ingress vr)
 743          */
 744         fc_key.kern_tb_id = l3mdev_fib_table(n_cache->key.dev);
 745         fib_cache = prestera_kern_fib_cache_find(sw, &fc_key);
 746         memset(&fib_key, 0, sizeof(fib_key));
 747         fib_key.addr = n_cache->key.addr;
 748         fib_key.prefix_len = PRESTERA_IP_ADDR_PLEN(n_cache->key.addr.v);
 749         fib_key.tb_id = prestera_fix_tb_id(fc_key.kern_tb_id);
 750         fib_node = prestera_fib_node_find(sw, &fib_key);
 751         if (!fib_cache || !fib_cache->reachable) {
 752                 if (!enabled && fib_node) {
 753                         if (prestera_fib_node_util_is_neighbour(fib_node))
 754                                 prestera_fib_node_destroy(sw, fib_node);
 755                         return;
 756                 }
 757         }
 758
 759         if (enabled && !fib_node) {
 760                 memset(&nh_grp_key, 0, sizeof(nh_grp_key));
 761                 prestera_util_nc_key2nh_key(&n_cache->key,
 762                                             &nh_grp_key.neigh[0]);
 763                 fib_node = prestera_fib_node_create(sw, &fib_key,
 764                                                     PRESTERA_FIB_TYPE_UC_NH,
 765                                                     &nh_grp_key);
 766                 if (!fib_node)
 767                         pr_err("%s failed ip=%pI4n", "prestera_fib_node_create",
 768                                &fib_key.addr.u.ipv4);
 769                 return;
 770         }
 771 }
 772
 773 static void
 774 __prestera_k_arb_nc_kern_fib_fetch(struct prestera_switch *sw,
 775                                    struct prestera_kern_neigh_cache *nc)
 776 {
 777         if (prestera_util_kern_n_is_reachable(l3mdev_fib_table(nc->key.dev),
 778                                               &nc->key.addr, nc->key.dev))
 779                 nc->reachable = true;
 780         else
 781                 nc->reachable = false;
 782 }
 783
 784 /* Kernel neighbour -> neigh_cache info */
 785 static void
 786 __prestera_k_arb_nc_kern_n_fetch(struct prestera_switch *sw,
 787                                  struct prestera_kern_neigh_cache *nc)
 788 {
 789         struct neighbour *n;
 790         int err;
 791
 792         memset(&nc->nh_neigh_info, 0, sizeof(nc->nh_neigh_info));
 793         n = neigh_lookup(&arp_tbl, &nc->key.addr.u.ipv4, nc->key.dev);
 794         if (!n)
 795                 goto out;
 796
 797         read_lock_bh(&n->lock);
 798         if (n->nud_state & NUD_VALID && !n->dead) {
 799                 err = prestera_neigh_iface_init(sw, &nc->nh_neigh_info.iface,
 800                                                 n);
 801                 if (err)
 802                         goto n_read_out;
 803
 804                 memcpy(&nc->nh_neigh_info.ha[0], &n->ha[0], ETH_ALEN);
 805                 nc->nh_neigh_info.connected = true;
 806         }
 807 n_read_out:
 808         read_unlock_bh(&n->lock);
 809 out:
 810         nc->in_kernel = nc->nh_neigh_info.connected;
 811         if (n)
 812                 neigh_release(n);
 813 }
 814
 815 /* neigh_cache info -> lpm update */
 816 static void
 817 __prestera_k_arb_nc_apply(struct prestera_switch *sw,
 818                           struct prestera_kern_neigh_cache *nc)
 819 {
 820         struct prestera_kern_neigh_cache_head *nhead;
 821         struct prestera_nh_neigh_key nh_key;
 822         struct prestera_nh_neigh *nh_neigh;
 823         int err;
 824
 825         __prestera_k_arb_n_lpm_set(sw, nc, nc->reachable && nc->in_kernel);
 826         __prestera_k_arb_n_offload_set(sw, nc, nc->reachable && nc->in_kernel);
 827
 828         prestera_util_nc_key2nh_key(&nc->key, &nh_key);
 829         nh_neigh = prestera_nh_neigh_find(sw, &nh_key);
 830         if (!nh_neigh)
 831                 goto out;
 832
 833         /* Do hw update only if something changed to prevent nh flap */
 834         if (memcmp(&nc->nh_neigh_info, &nh_neigh->info,
 835                    sizeof(nh_neigh->info))) {
 836                 memcpy(&nh_neigh->info, &nc->nh_neigh_info,
 837                        sizeof(nh_neigh->info));
 838                 err = prestera_nh_neigh_set(sw, nh_neigh);
 839                 if (err) {
 840                         pr_err("%s failed with err=%d ip=%pI4n mac=%pM",
 841                                "prestera_nh_neigh_set", err,
 842                                &nh_neigh->key.addr.u.ipv4,
 843                                &nh_neigh->info.ha[0]);
 844                         goto out;
 845                 }
 846         }
 847
 848 out:
 849         list_for_each_entry(nhead, &nc->kern_fib_cache_list, head) {
 850                 __prestera_k_arb_fib_nh_offload_set(sw, nhead->this, nc,
 851                                                     nc->in_kernel,
 852                                                     !nc->in_kernel);
 853         }
 854 }
 855
 856 static int
 857 __prestera_pr_k_arb_fc_lpm_info_calc(struct prestera_switch *sw,
 858                                      struct prestera_kern_fib_cache *fc)
 859 {
 860         struct fib_nh_common *nhc;
 861         int nh_cnt;
 862
 863         memset(&fc->lpm_info, 0, sizeof(fc->lpm_info));
 864
 865         switch (prestera_kern_fib_info_type(&fc->info)) {
 866         case RTN_UNICAST:
 867                 if (prestera_fib_info_is_direct(&fc->info) &&
 868                     fc->key.prefix_len ==
 869                         PRESTERA_IP_ADDR_PLEN(fc->key.addr.v)) {
 870                         /* This is special case.
 871                          * When prefix is 32. Than we will have conflict in lpm
 872                          * for direct route - once TRAP added, there is no
 873                          * place for neighbour entry. So represent direct route
 874                          * with prefix 32, as NH. So neighbour will be resolved
 875                          * as nexthop of this route.
 876                          */
 877                         nhc = prestera_kern_fib_info_nhc(&fc->info, 0);
 878                         fc->lpm_info.fib_type = PRESTERA_FIB_TYPE_UC_NH;
 879                         fc->lpm_info.nh_grp_key.neigh[0].addr =
 880                                 fc->key.addr;
 881                         fc->lpm_info.nh_grp_key.neigh[0].rif =
 882                                 nhc->nhc_dev;
 883
 884                         break;
 885                 }
 886
 887                 /* We can also get nh_grp_key from fi. This will be correct to
 888                  * because cache not always represent, what actually written to
 889                  * lpm. But we use nh cache, as well for now (for this case).
 890                  */
 891                 for (nh_cnt = 0; nh_cnt < PRESTERA_NHGR_SIZE_MAX; nh_cnt++) {
 892                         if (!fc->kern_neigh_cache_head[nh_cnt].n_cache)
 893                                 break;
 894
 895                         fc->lpm_info.nh_grp_key.neigh[nh_cnt].addr =
 896                                 fc->kern_neigh_cache_head[nh_cnt].n_cache->key.addr;
 897                         fc->lpm_info.nh_grp_key.neigh[nh_cnt].rif =
 898                                 fc->kern_neigh_cache_head[nh_cnt].n_cache->key.dev;
 899                 }
 900
 901                 fc->lpm_info.fib_type = nh_cnt ?
 902                                         PRESTERA_FIB_TYPE_UC_NH :
 903                                         PRESTERA_FIB_TYPE_TRAP;
 904                 break;
 905         /* Unsupported. Leave it for kernel: */
 906         case RTN_BROADCAST:
 907         case RTN_MULTICAST:
 908         /* Routes we must trap by design: */
 909         case RTN_LOCAL:
 910         case RTN_UNREACHABLE:
 911         case RTN_PROHIBIT:
 912                 fc->lpm_info.fib_type = PRESTERA_FIB_TYPE_TRAP;
 913                 break;
 914         case RTN_BLACKHOLE:
 915                 fc->lpm_info.fib_type = PRESTERA_FIB_TYPE_DROP;
 916                 break;
 917         default:
 918                 dev_err(sw->dev->dev, "Unsupported fib_type");
 919                 return -EOPNOTSUPP;
 920         }
 921
 922         fc->lpm_info.fib_key.addr = fc->key.addr;
 923         fc->lpm_info.fib_key.prefix_len = fc->key.prefix_len;
 924         fc->lpm_info.fib_key.tb_id = prestera_fix_tb_id(fc->key.kern_tb_id);
 925
 926         return 0;
 927 }
 928
 929 static int __prestera_k_arb_f_lpm_set(struct prestera_switch *sw,
 930                                       struct prestera_kern_fib_cache *fc,
 931                                       bool enabled)
 932 {
 933         struct prestera_fib_node *fib_node;
 934
 935         fib_node = prestera_fib_node_find(sw, &fc->lpm_info.fib_key);
 936         if (fib_node)
 937                 prestera_fib_node_destroy(sw, fib_node);
 938
 939         if (!enabled)
 940                 return 0;
 941
 942         fib_node = prestera_fib_node_create(sw, &fc->lpm_info.fib_key,
 943                                             fc->lpm_info.fib_type,
 944                                             &fc->lpm_info.nh_grp_key);
 945
 946         if (!fib_node) {
 947                 dev_err(sw->dev->dev, "fib_node=NULL %pI4n/%d kern_tb_id = %d",
 948                         &fc->key.addr.u.ipv4, fc->key.prefix_len,
 949                         fc->key.kern_tb_id);
 950                 return -ENOENT;
 951         }
 952
 953         return 0;
 954 }
 955
 956 static int __prestera_k_arb_fc_apply(struct prestera_switch *sw,
 957                                      struct prestera_kern_fib_cache *fc)
 958 {
 959         int err;
 960
 961         err = __prestera_pr_k_arb_fc_lpm_info_calc(sw, fc);
 962         if (err)
 963                 return err;
 964
 965         err = __prestera_k_arb_f_lpm_set(sw, fc, fc->reachable);
 966         if (err) {
 967                 __prestera_k_arb_fib_lpm_offload_set(sw, fc,
 968                                                      true, false, false);
 969                 return err;
 970         }
 971
 972         switch (fc->lpm_info.fib_type) {
 973         case PRESTERA_FIB_TYPE_UC_NH:
 974                 __prestera_k_arb_fib_lpm_offload_set(sw, fc, false,
 975                                                      fc->reachable, false);
 976                 break;
 977         case PRESTERA_FIB_TYPE_TRAP:
 978                 __prestera_k_arb_fib_lpm_offload_set(sw, fc, false,
 979                                                      false, fc->reachable);
 980                 break;
 981         case PRESTERA_FIB_TYPE_DROP:
 982                 __prestera_k_arb_fib_lpm_offload_set(sw, fc, false, true,
 983                                                      fc->reachable);
 984                 break;
 985         case PRESTERA_FIB_TYPE_INVALID:
 986                 break;
 987         }
 988
 989         return 0;
 990 }
 991
 992 static struct prestera_kern_fib_cache *
 993 __prestera_k_arb_util_fib_overlaps(struct prestera_switch *sw,
 994                                    struct prestera_kern_fib_cache *fc)
 995 {
 996         struct prestera_kern_fib_cache_key fc_key;
 997         struct prestera_kern_fib_cache *rfc;
 998
 999         /* TODO: parse kernel rules */
1000         rfc = NULL;
1001         if (fc->key.kern_tb_id == RT_TABLE_LOCAL) {
1002                 memcpy(&fc_key, &fc->key, sizeof(fc_key));
1003                 fc_key.kern_tb_id = RT_TABLE_MAIN;
1004                 rfc = prestera_kern_fib_cache_find(sw, &fc_key);
1005         }
1006
1007         return rfc;
1008 }
1009
1010 static struct prestera_kern_fib_cache *
1011 __prestera_k_arb_util_fib_overlapped(struct prestera_switch *sw,
1012                                      struct prestera_kern_fib_cache *fc)
1013 {
1014         struct prestera_kern_fib_cache_key fc_key;
1015         struct prestera_kern_fib_cache *rfc;
1016
1017         /* TODO: parse kernel rules */
1018         rfc = NULL;
1019         if (fc->key.kern_tb_id == RT_TABLE_MAIN) {
1020                 memcpy(&fc_key, &fc->key, sizeof(fc_key));
1021                 fc_key.kern_tb_id = RT_TABLE_LOCAL;
1022                 rfc = prestera_kern_fib_cache_find(sw, &fc_key);
1023         }
1024
1025         return rfc;
1026 }
1027
1028 static void __prestera_k_arb_hw_state_upd(struct prestera_switch *sw,
1029                                           struct prestera_kern_neigh_cache *nc)
1030 {
1031         struct prestera_nh_neigh_key nh_key;
1032         struct prestera_nh_neigh *nh_neigh;
1033         struct neighbour *n;
1034         bool hw_active;
1035
1036         prestera_util_nc_key2nh_key(&nc->key, &nh_key);
1037         nh_neigh = prestera_nh_neigh_find(sw, &nh_key);
1038         if (!nh_neigh) {
1039                 pr_err("Cannot find nh_neigh for cached %pI4n",
1040                        &nc->key.addr.u.ipv4);
1041                 return;
1042         }
1043
1044         hw_active = prestera_nh_neigh_util_hw_state(sw, nh_neigh);
1045
1046 #ifdef PRESTERA_IMPLICITY_RESOLVE_DEAD_NEIGH
1047         if (!hw_active && nc->in_kernel)
1048                 goto out;
1049 #else /* PRESTERA_IMPLICITY_RESOLVE_DEAD_NEIGH */
1050         if (!hw_active)
1051                 goto out;
1052 #endif /* PRESTERA_IMPLICITY_RESOLVE_DEAD_NEIGH */
1053
1054         if (nc->key.addr.v == PRESTERA_IPV4) {
1055                 n = neigh_lookup(&arp_tbl, &nc->key.addr.u.ipv4,
1056                                  nc->key.dev);
1057                 if (!n)
1058                         n = neigh_create(&arp_tbl, &nc->key.addr.u.ipv4,
1059                                          nc->key.dev);
1060         } else {
1061                 n = NULL;
1062         }
1063
1064         if (!IS_ERR(n) && n) {
1065                 neigh_event_send(n, NULL);
1066                 neigh_release(n);
1067         } else {
1068                 pr_err("Cannot create neighbour %pI4n", &nc->key.addr.u.ipv4);
1069         }
1070
1071 out:
1072         return;
1073 }
1074
1075 /* Propagate hw state to kernel */
1076 static void prestera_k_arb_hw_evt(struct prestera_switch *sw)
1077 {
1078         struct prestera_kern_neigh_cache *n_cache;
1079         struct rhashtable_iter iter;
1080
1081         rhashtable_walk_enter(&sw->router->kern_neigh_cache_ht, &iter);
1082         rhashtable_walk_start(&iter);
1083         while (1) {
1084                 n_cache = rhashtable_walk_next(&iter);
1085
1086                 if (!n_cache)
1087                         break;
1088
1089                 if (IS_ERR(n_cache))
1090                         continue;
1091
1092                 rhashtable_walk_stop(&iter);
1093                 __prestera_k_arb_hw_state_upd(sw, n_cache);
1094                 rhashtable_walk_start(&iter);
1095         }
1096         rhashtable_walk_stop(&iter);
1097         rhashtable_walk_exit(&iter);
1098 }
1099
1100 /* Propagate kernel event to hw */
1101 static void prestera_k_arb_n_evt(struct prestera_switch *sw,
1102                                  struct neighbour *n)
1103 {
1104         struct prestera_kern_neigh_cache_key n_key;
1105         struct prestera_kern_neigh_cache *n_cache;
1106         int err;
1107
1108         err = prestera_util_neigh2nc_key(sw, n, &n_key);
1109         if (err)
1110                 return;
1111
1112         n_cache = prestera_kern_neigh_cache_find(sw, &n_key);
1113         if (!n_cache) {
1114                 n_cache = prestera_kern_neigh_cache_get(sw, &n_key);
1115                 if (!n_cache)
1116                         return;
1117                 __prestera_k_arb_nc_kern_fib_fetch(sw, n_cache);
1118         }
1119
1120         __prestera_k_arb_nc_kern_n_fetch(sw, n_cache);
1121         __prestera_k_arb_nc_apply(sw, n_cache);
1122
1123         prestera_kern_neigh_cache_put(sw, n_cache);
1124 }
1125
1126 static void __prestera_k_arb_fib_evt2nc(struct prestera_switch *sw)
1127 {
1128         struct prestera_kern_neigh_cache *n_cache;
1129         struct rhashtable_iter iter;
1130
1131         rhashtable_walk_enter(&sw->router->kern_neigh_cache_ht, &iter);
1132         rhashtable_walk_start(&iter);
1133         while (1) {
1134                 n_cache = rhashtable_walk_next(&iter);
1135
1136                 if (!n_cache)
1137                         break;
1138
1139                 if (IS_ERR(n_cache))
1140                         continue;
1141
1142                 rhashtable_walk_stop(&iter);
1143                 __prestera_k_arb_nc_kern_fib_fetch(sw, n_cache);
1144                 __prestera_k_arb_nc_apply(sw, n_cache);
1145                 rhashtable_walk_start(&iter);
1146         }
1147         rhashtable_walk_stop(&iter);
1148         rhashtable_walk_exit(&iter);
1149 }
1150
1151 static int
1152 prestera_k_arb_fib_evt(struct prestera_switch *sw,
1153                        bool replace, /* replace or del */
1154                        struct fib_notifier_info *info)
1155 {
1156         struct prestera_kern_fib_cache *tfib_cache, *bfib_cache; /* top/btm */
1157         struct prestera_kern_fib_cache_key fc_key;
1158         struct prestera_kern_fib_cache *fib_cache;
1159         int err;
1160
1161         prestera_util_fen_info2fib_cache_key(info, &fc_key);
1162         fib_cache = prestera_kern_fib_cache_find(sw, &fc_key);
1163         if (fib_cache) {
1164                 fib_cache->reachable = false;
1165                 err = __prestera_k_arb_fc_apply(sw, fib_cache);
1166                 if (err)
1167                         dev_err(sw->dev->dev,
1168                                 "Applying destroyed fib_cache failed");
1169
1170                 bfib_cache = __prestera_k_arb_util_fib_overlaps(sw, fib_cache);
1171                 tfib_cache = __prestera_k_arb_util_fib_overlapped(sw, fib_cache);
1172                 if (!tfib_cache && bfib_cache) {
1173                         bfib_cache->reachable = true;
1174                         err = __prestera_k_arb_fc_apply(sw, bfib_cache);
1175                         if (err)
1176                                 dev_err(sw->dev->dev,
1177                                         "Applying fib_cache btm failed");
1178                 }
1179
1180                 prestera_kern_fib_cache_destroy(sw, fib_cache);
1181         }
1182
1183         if (replace) {
1184                 fib_cache = prestera_kern_fib_cache_create(sw, &fc_key, info);
1185                 if (!fib_cache) {
1186                         dev_err(sw->dev->dev, "fib_cache == NULL");
1187                         return -ENOENT;
1188                 }
1189
1190                 bfib_cache = __prestera_k_arb_util_fib_overlaps(sw, fib_cache);
1191                 tfib_cache = __prestera_k_arb_util_fib_overlapped(sw, fib_cache);
1192                 if (!tfib_cache)
1193                         fib_cache->reachable = true;
1194
1195                 if (bfib_cache) {
1196                         bfib_cache->reachable = false;
1197                         err = __prestera_k_arb_fc_apply(sw, bfib_cache);
1198                         if (err)
1199                                 dev_err(sw->dev->dev,
1200                                         "Applying fib_cache btm failed");
1201                 }
1202
1203                 err = __prestera_k_arb_fc_apply(sw, fib_cache);
1204                 if (err)
1205                         dev_err(sw->dev->dev, "Applying fib_cache failed");
1206         }
1207
1208         /* Update all neighs to resolve overlapped and apply related */
1209         __prestera_k_arb_fib_evt2nc(sw);
1210
1211         return 0;
1212 }
1213
1214 static void __prestera_k_arb_abort_neigh_ht_cb(void *ptr, void *arg)
1215 {
1216         struct prestera_kern_neigh_cache *n_cache = ptr;
1217         struct prestera_switch *sw = arg;
1218
1219         if (!list_empty(&n_cache->kern_fib_cache_list)) {
1220                 WARN_ON(1); /* BUG */
1221                 return;
1222         }
1223         __prestera_k_arb_n_offload_set(sw, n_cache, false);
1224         n_cache->in_kernel = false;
1225         /* No need to destroy lpm.
1226          * It will be aborted by destroy_ht
1227          */
1228         __prestera_kern_neigh_cache_destruct(sw, n_cache);
1229         kfree(n_cache);
1230 }
1231
1232 static void __prestera_k_arb_abort_fib_ht_cb(void *ptr, void *arg)
1233 {
1234         struct prestera_kern_fib_cache *fib_cache = ptr;
1235         struct prestera_switch *sw = arg;
1236
1237         __prestera_k_arb_fib_lpm_offload_set(sw, fib_cache,
1238                                              false, false,
1239                                              false);
1240         __prestera_k_arb_fib_nh_offload_set(sw, fib_cache, NULL,
1241                                             false, false);
1242         /* No need to destroy lpm.
1243          * It will be aborted by destroy_ht
1244          */
1245         __prestera_kern_fib_cache_destruct(sw, fib_cache);
1246         kfree(fib_cache);
1247 }
1248
1249 static void prestera_k_arb_abort(struct prestera_switch *sw)
1250 {
1251         /* Function to remove all arbiter entries and related hw objects. */
1252         /* Sequence:
1253          *   1) Clear arbiter tables, but don't touch hw
1254          *   2) Clear hw
1255          * We use such approach, because arbiter object is not directly mapped
1256          * to hw. So deletion of one arbiter object may even lead to creation of
1257          * hw object (e.g. in case of overlapped routes).
1258          */
1259         rhashtable_free_and_destroy(&sw->router->kern_fib_cache_ht,
1260                                     __prestera_k_arb_abort_fib_ht_cb,
1261                                     sw);
1262         rhashtable_free_and_destroy(&sw->router->kern_neigh_cache_ht,
1263                                     __prestera_k_arb_abort_neigh_ht_cb,
1264                                     sw);
1265 }
1266
1267 static int __prestera_inetaddr_port_event(struct net_device *port_dev,
1268                                           unsigned long event,
1269                                           struct netlink_ext_ack *extack)
1270 {
1271         struct prestera_port *port = netdev_priv(port_dev);
1272         struct prestera_rif_entry_key re_key = {};
1273         struct prestera_rif_entry *re;
1274         u32 kern_tb_id;
1275         int err;
1276
1277         err = prestera_is_valid_mac_addr(port, port_dev->dev_addr);
1278         if (err) {
1279                 NL_SET_ERR_MSG_MOD(extack, "RIF MAC must have the same prefix");
1280                 return err;
1281         }
1282
1283         kern_tb_id = l3mdev_fib_table(port_dev);
1284         re_key.iface.type = PRESTERA_IF_PORT_E;
1285         re_key.iface.dev_port.hw_dev_num  = port->dev_id;
1286         re_key.iface.dev_port.port_num  = port->hw_id;
1287         re = prestera_rif_entry_find(port->sw, &re_key);
1288
1289         switch (event) {
1290         case NETDEV_UP:
1291                 if (re) {
1292                         NL_SET_ERR_MSG_MOD(extack, "RIF already exist");
1293                         return -EEXIST;
1294                 }
1295                 re = prestera_rif_entry_create(port->sw, &re_key,
1296                                                prestera_fix_tb_id(kern_tb_id),
1297                                                port_dev->dev_addr);
1298                 if (!re) {
1299                         NL_SET_ERR_MSG_MOD(extack, "Can't create RIF");
1300                         return -EINVAL;
1301                 }
1302                 dev_hold(port_dev);
1303                 break;
1304         case NETDEV_DOWN:
1305                 if (!re) {
1306                         NL_SET_ERR_MSG_MOD(extack, "Can't find RIF");
1307                         return -EEXIST;
1308                 }
1309                 prestera_rif_entry_destroy(port->sw, re);
1310                 dev_put(port_dev);
1311                 break;
1312         }
1313
1314         return 0;
1315 }
1316
1317 static int __prestera_inetaddr_event(struct prestera_switch *sw,
1318                                      struct net_device *dev,
1319                                      unsigned long event,
1320                                      struct netlink_ext_ack *extack)
1321 {
1322         if (!prestera_netdev_check(dev) || netif_is_any_bridge_port(dev) ||
1323             netif_is_lag_port(dev))
1324                 return 0;
1325
1326         return __prestera_inetaddr_port_event(dev, event, extack);
1327 }
1328
1329 static int __prestera_inetaddr_cb(struct notifier_block *nb,
1330                                   unsigned long event, void *ptr)
1331 {
1332         struct in_ifaddr *ifa = (struct in_ifaddr *)ptr;
1333         struct net_device *dev = ifa->ifa_dev->dev;
1334         struct prestera_router *router = container_of(nb,
1335                                                       struct prestera_router,
1336                                                       inetaddr_nb);
1337         struct in_device *idev;
1338         int err = 0;
1339
1340         if (event != NETDEV_DOWN)
1341                 goto out;
1342
1343         /* Ignore if this is not latest address */
1344         idev = __in_dev_get_rtnl(dev);
1345         if (idev && idev->ifa_list)
1346                 goto out;
1347
1348         err = __prestera_inetaddr_event(router->sw, dev, event, NULL);
1349 out:
1350         return notifier_from_errno(err);
1351 }
1352
1353 static int __prestera_inetaddr_valid_cb(struct notifier_block *nb,
1354                                         unsigned long event, void *ptr)
1355 {
1356         struct in_validator_info *ivi = (struct in_validator_info *)ptr;
1357         struct net_device *dev = ivi->ivi_dev->dev;
1358         struct prestera_router *router = container_of(nb,
1359                                                       struct prestera_router,
1360                                                       inetaddr_valid_nb);
1361         struct in_device *idev;
1362         int err = 0;
1363
1364         if (event != NETDEV_UP)
1365                 goto out;
1366
1367         /* Ignore if this is not first address */
1368         idev = __in_dev_get_rtnl(dev);
1369         if (idev && idev->ifa_list)
1370                 goto out;
1371
1372         if (ipv4_is_multicast(ivi->ivi_addr)) {
1373                 NL_SET_ERR_MSG_MOD(ivi->extack,
1374                                    "Multicast addr on RIF is not supported");
1375                 err = -EINVAL;
1376                 goto out;
1377         }
1378
1379         err = __prestera_inetaddr_event(router->sw, dev, event, ivi->extack);
1380 out:
1381         return notifier_from_errno(err);
1382 }
1383
1384 struct prestera_fib_event_work {
1385         struct work_struct work;
1386         struct prestera_switch *sw;
1387         struct fib_entry_notifier_info fen_info;
1388         unsigned long event;
1389 };
1390
1391 static void __prestera_router_fib_event_work(struct work_struct *work)
1392 {
1393         struct prestera_fib_event_work *fib_work =
1394                         container_of(work, struct prestera_fib_event_work, work);
1395         struct prestera_switch *sw = fib_work->sw;
1396         int err;
1397
1398         rtnl_lock();
1399
1400         switch (fib_work->event) {
1401         case FIB_EVENT_ENTRY_REPLACE:
1402                 err = prestera_k_arb_fib_evt(sw, true,
1403                                              &fib_work->fen_info.info);
1404                 if (err)
1405                         goto err_out;
1406
1407                 break;
1408         case FIB_EVENT_ENTRY_DEL:
1409                 err = prestera_k_arb_fib_evt(sw, false,
1410                                              &fib_work->fen_info.info);
1411                 if (err)
1412                         goto err_out;
1413
1414                 break;
1415         }
1416
1417         goto out;
1418
1419 err_out:
1420         dev_err(sw->dev->dev, "Error when processing %pI4h/%d",
1421                 &fib_work->fen_info.dst,
1422                 fib_work->fen_info.dst_len);
1423 out:
1424         fib_info_put(fib_work->fen_info.fi);
1425         rtnl_unlock();
1426         kfree(fib_work);
1427 }
1428
1429 /* Called with rcu_read_lock() */
1430 static int __prestera_router_fib_event(struct notifier_block *nb,
1431                                        unsigned long event, void *ptr)
1432 {
1433         struct prestera_fib_event_work *fib_work;
1434         struct fib_entry_notifier_info *fen_info;
1435         struct fib_notifier_info *info = ptr;
1436         struct prestera_router *router;
1437
1438         if (info->family != AF_INET)
1439                 return NOTIFY_DONE;
1440
1441         router = container_of(nb, struct prestera_router, fib_nb);
1442
1443         switch (event) {
1444         case FIB_EVENT_ENTRY_REPLACE:
1445         case FIB_EVENT_ENTRY_DEL:
1446                 fen_info = container_of(info, struct fib_entry_notifier_info,
1447                                         info);
1448                 if (!fen_info->fi)
1449                         return NOTIFY_DONE;
1450
1451                 fib_work = kzalloc(sizeof(*fib_work), GFP_ATOMIC);
1452                 if (WARN_ON(!fib_work))
1453                         return NOTIFY_BAD;
1454
1455                 fib_info_hold(fen_info->fi);
1456                 fib_work->fen_info = *fen_info;
1457                 fib_work->event = event;
1458                 fib_work->sw = router->sw;
1459                 INIT_WORK(&fib_work->work, __prestera_router_fib_event_work);
1460                 prestera_queue_work(&fib_work->work);
1461                 break;
1462         default:
1463                 return NOTIFY_DONE;
1464         }
1465
1466         return NOTIFY_DONE;
1467 }
1468
1469 struct prestera_netevent_work {
1470         struct work_struct work;
1471         struct prestera_switch *sw;
1472         struct neighbour *n;
1473 };
1474
1475 static void prestera_router_neigh_event_work(struct work_struct *work)
1476 {
1477         struct prestera_netevent_work *net_work =
1478                 container_of(work, struct prestera_netevent_work, work);
1479         struct prestera_switch *sw = net_work->sw;
1480         struct neighbour *n = net_work->n;
1481
1482         /* neigh - its not hw related object. It stored only in kernel. So... */
1483         rtnl_lock();
1484
1485         prestera_k_arb_n_evt(sw, n);
1486
1487         neigh_release(n);
1488         rtnl_unlock();
1489         kfree(net_work);
1490 }
1491
1492 static int prestera_router_netevent_event(struct notifier_block *nb,
1493                                           unsigned long event, void *ptr)
1494 {
1495         struct prestera_netevent_work *net_work;
1496         struct prestera_router *router;
1497         struct neighbour *n = ptr;
1498
1499         router = container_of(nb, struct prestera_router, netevent_nb);
1500
1501         switch (event) {
1502         case NETEVENT_NEIGH_UPDATE:
1503                 if (n->tbl->family != AF_INET)
1504                         return NOTIFY_DONE;
1505
1506                 net_work = kzalloc(sizeof(*net_work), GFP_ATOMIC);
1507                 if (WARN_ON(!net_work))
1508                         return NOTIFY_BAD;
1509
1510                 neigh_clone(n);
1511                 net_work->n = n;
1512                 net_work->sw = router->sw;
1513                 INIT_WORK(&net_work->work, prestera_router_neigh_event_work);
1514                 prestera_queue_work(&net_work->work);
1515         }
1516
1517         return NOTIFY_DONE;
1518 }
1519
1520 static void prestera_router_update_neighs_work(struct work_struct *work)
1521 {
1522         struct prestera_router *router;
1523
1524         router = container_of(work, struct prestera_router,
1525                               neighs_update.dw.work);
1526         rtnl_lock();
1527
1528         prestera_k_arb_hw_evt(router->sw);
1529
1530         rtnl_unlock();
1531         prestera_queue_delayed_work(&router->neighs_update.dw,
1532                                     msecs_to_jiffies(PRESTERA_NH_PROBE_INTERVAL));
1533 }
1534
1535 static int prestera_neigh_work_init(struct prestera_switch *sw)
1536 {
1537         INIT_DELAYED_WORK(&sw->router->neighs_update.dw,
1538                           prestera_router_update_neighs_work);
1539         prestera_queue_delayed_work(&sw->router->neighs_update.dw, 0);
1540         return 0;
1541 }
1542
1543 static void prestera_neigh_work_fini(struct prestera_switch *sw)
1544 {
1545         cancel_delayed_work_sync(&sw->router->neighs_update.dw);
1546 }
1547
1548 int prestera_router_init(struct prestera_switch *sw)
1549 {
1550         struct prestera_router *router;
1551         int err, nhgrp_cache_bytes;
1552
1553         router = kzalloc(sizeof(*sw->router), GFP_KERNEL);
1554         if (!router)
1555                 return -ENOMEM;
1556
1557         sw->router = router;
1558         router->sw = sw;
1559
1560         err = prestera_router_hw_init(sw);
1561         if (err)
1562                 goto err_router_lib_init;
1563
1564         err = rhashtable_init(&router->kern_fib_cache_ht,
1565                               &__prestera_kern_fib_cache_ht_params);
1566         if (err)
1567                 goto err_kern_fib_cache_ht_init;
1568
1569         err = rhashtable_init(&router->kern_neigh_cache_ht,
1570                               &__prestera_kern_neigh_cache_ht_params);
1571         if (err)
1572                 goto err_kern_neigh_cache_ht_init;
1573
1574         nhgrp_cache_bytes = sw->size_tbl_router_nexthop / 8 + 1;
1575         router->nhgrp_hw_state_cache = kzalloc(nhgrp_cache_bytes, GFP_KERNEL);
1576         if (!router->nhgrp_hw_state_cache) {
1577                 err = -ENOMEM;
1578                 goto err_nh_state_cache_alloc;
1579         }
1580
1581         err = prestera_neigh_work_init(sw);
1582         if (err)
1583                 goto err_neigh_work_init;
1584
1585         router->inetaddr_valid_nb.notifier_call = __prestera_inetaddr_valid_cb;
1586         err = register_inetaddr_validator_notifier(&router->inetaddr_valid_nb);
1587         if (err)
1588                 goto err_register_inetaddr_validator_notifier;
1589
1590         router->inetaddr_nb.notifier_call = __prestera_inetaddr_cb;
1591         err = register_inetaddr_notifier(&router->inetaddr_nb);
1592         if (err)
1593                 goto err_register_inetaddr_notifier;
1594
1595         router->netevent_nb.notifier_call = prestera_router_netevent_event;
1596         err = register_netevent_notifier(&router->netevent_nb);
1597         if (err)
1598                 goto err_register_netevent_notifier;
1599
1600         router->fib_nb.notifier_call = __prestera_router_fib_event;
1601         err = register_fib_notifier(&init_net, &router->fib_nb,
1602                                     /* TODO: flush fib entries */ NULL, NULL);
1603         if (err)
1604                 goto err_register_fib_notifier;
1605
1606         return 0;
1607
1608 err_register_fib_notifier:
1609         unregister_netevent_notifier(&router->netevent_nb);
1610 err_register_netevent_notifier:
1611         unregister_inetaddr_notifier(&router->inetaddr_nb);
1612 err_register_inetaddr_notifier:
1613         unregister_inetaddr_validator_notifier(&router->inetaddr_valid_nb);
1614 err_register_inetaddr_validator_notifier:
1615         prestera_neigh_work_fini(sw);
1616 err_neigh_work_init:
1617         kfree(router->nhgrp_hw_state_cache);
1618 err_nh_state_cache_alloc:
1619         rhashtable_destroy(&router->kern_neigh_cache_ht);
1620 err_kern_neigh_cache_ht_init:
1621         rhashtable_destroy(&router->kern_fib_cache_ht);
1622 err_kern_fib_cache_ht_init:
1623         prestera_router_hw_fini(sw);
1624 err_router_lib_init:
1625         kfree(sw->router);
1626         return err;
1627 }
1628
1629 void prestera_router_fini(struct prestera_switch *sw)
1630 {
1631         unregister_fib_notifier(&init_net, &sw->router->fib_nb);
1632         unregister_netevent_notifier(&sw->router->netevent_nb);
1633         unregister_inetaddr_notifier(&sw->router->inetaddr_nb);
1634         unregister_inetaddr_validator_notifier(&sw->router->inetaddr_valid_nb);
1635         prestera_neigh_work_fini(sw);
1636         prestera_queue_drain();
1637
1638         prestera_k_arb_abort(sw);
1639
1640         kfree(sw->router->nhgrp_hw_state_cache);
1641         rhashtable_destroy(&sw->router->kern_fib_cache_ht);
1642         prestera_router_hw_fini(sw);
1643         kfree(sw->router);
1644         sw->router = NULL;
1645 }