drivers/net/ethernet/mellanox/mlxsw/spectrum_mr.c

   1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
   2 /* Copyright (c) 2017-2018 Mellanox Technologies. All rights reserved */
   3
   4 #include <linux/mutex.h>
   5 #include <linux/rhashtable.h>
   6 #include <net/ipv6.h>
   7
   8 #include "spectrum_mr.h"
   9 #include "spectrum_router.h"
  10
  11 struct mlxsw_sp_mr {
  12         const struct mlxsw_sp_mr_ops *mr_ops;
  13         void *catchall_route_priv;
  14         struct delayed_work stats_update_dw;
  15         struct list_head table_list;
  16         struct mutex table_list_lock; /* Protects table_list */
  17 #define MLXSW_SP_MR_ROUTES_COUNTER_UPDATE_INTERVAL 5000 /* ms */
  18         unsigned long priv[0];
  19         /* priv has to be always the last item */
  20 };
  21
  22 struct mlxsw_sp_mr_vif;
  23 struct mlxsw_sp_mr_vif_ops {
  24         bool (*is_regular)(const struct mlxsw_sp_mr_vif *vif);
  25 };
  26
  27 struct mlxsw_sp_mr_vif {
  28         struct net_device *dev;
  29         const struct mlxsw_sp_rif *rif;
  30         unsigned long vif_flags;
  31
  32         /* A list of route_vif_entry structs that point to routes that the VIF
  33          * instance is used as one of the egress VIFs
  34          */
  35         struct list_head route_evif_list;
  36
  37         /* A list of route_vif_entry structs that point to routes that the VIF
  38          * instance is used as an ingress VIF
  39          */
  40         struct list_head route_ivif_list;
  41
  42         /* Protocol specific operations for a VIF */
  43         const struct mlxsw_sp_mr_vif_ops *ops;
  44 };
  45
  46 struct mlxsw_sp_mr_route_vif_entry {
  47         struct list_head vif_node;
  48         struct list_head route_node;
  49         struct mlxsw_sp_mr_vif *mr_vif;
  50         struct mlxsw_sp_mr_route *mr_route;
  51 };
  52
  53 struct mlxsw_sp_mr_table;
  54 struct mlxsw_sp_mr_table_ops {
  55         bool (*is_route_valid)(const struct mlxsw_sp_mr_table *mr_table,
  56                                const struct mr_mfc *mfc);
  57         void (*key_create)(struct mlxsw_sp_mr_table *mr_table,
  58                            struct mlxsw_sp_mr_route_key *key,
  59                            struct mr_mfc *mfc);
  60         bool (*is_route_starg)(const struct mlxsw_sp_mr_table *mr_table,
  61                                const struct mlxsw_sp_mr_route *mr_route);
  62 };
  63
  64 struct mlxsw_sp_mr_table {
  65         struct list_head node;
  66         enum mlxsw_sp_l3proto proto;
  67         struct mlxsw_sp *mlxsw_sp;
  68         u32 vr_id;
  69         struct mlxsw_sp_mr_vif vifs[MAXVIFS];
  70         struct list_head route_list;
  71         struct mutex route_list_lock; /* Protects route_list */
  72         struct rhashtable route_ht;
  73         const struct mlxsw_sp_mr_table_ops *ops;
  74         char catchall_route_priv[];
  75         /* catchall_route_priv has to be always the last item */
  76 };
  77
  78 struct mlxsw_sp_mr_route {
  79         struct list_head node;
  80         struct rhash_head ht_node;
  81         struct mlxsw_sp_mr_route_key key;
  82         enum mlxsw_sp_mr_route_action route_action;
  83         u16 min_mtu;
  84         struct mr_mfc *mfc;
  85         void *route_priv;
  86         const struct mlxsw_sp_mr_table *mr_table;
  87         /* A list of route_vif_entry structs that point to the egress VIFs */
  88         struct list_head evif_list;
  89         /* A route_vif_entry struct that point to the ingress VIF */
  90         struct mlxsw_sp_mr_route_vif_entry ivif;
  91 };
  92
  93 static const struct rhashtable_params mlxsw_sp_mr_route_ht_params = {
  94         .key_len = sizeof(struct mlxsw_sp_mr_route_key),
  95         .key_offset = offsetof(struct mlxsw_sp_mr_route, key),
  96         .head_offset = offsetof(struct mlxsw_sp_mr_route, ht_node),
  97         .automatic_shrinking = true,
  98 };
  99
 100 static bool mlxsw_sp_mr_vif_valid(const struct mlxsw_sp_mr_vif *vif)
 101 {
 102         return vif->ops->is_regular(vif) && vif->dev && vif->rif;
 103 }
 104
 105 static bool mlxsw_sp_mr_vif_exists(const struct mlxsw_sp_mr_vif *vif)
 106 {
 107         return vif->dev;
 108 }
 109
 110 static bool
 111 mlxsw_sp_mr_route_ivif_in_evifs(const struct mlxsw_sp_mr_route *mr_route)
 112 {
 113         vifi_t ivif = mr_route->mfc->mfc_parent;
 114
 115         return mr_route->mfc->mfc_un.res.ttls[ivif] != 255;
 116 }
 117
 118 static int
 119 mlxsw_sp_mr_route_valid_evifs_num(const struct mlxsw_sp_mr_route *mr_route)
 120 {
 121         struct mlxsw_sp_mr_route_vif_entry *rve;
 122         int valid_evifs;
 123
 124         valid_evifs = 0;
 125         list_for_each_entry(rve, &mr_route->evif_list, route_node)
 126                 if (mlxsw_sp_mr_vif_valid(rve->mr_vif))
 127                         valid_evifs++;
 128         return valid_evifs;
 129 }
 130
 131 static enum mlxsw_sp_mr_route_action
 132 mlxsw_sp_mr_route_action(const struct mlxsw_sp_mr_route *mr_route)
 133 {
 134         struct mlxsw_sp_mr_route_vif_entry *rve;
 135
 136         /* If the ingress port is not regular and resolved, trap the route */
 137         if (!mlxsw_sp_mr_vif_valid(mr_route->ivif.mr_vif))
 138                 return MLXSW_SP_MR_ROUTE_ACTION_TRAP;
 139
 140         /* The kernel does not match a (*,G) route that the ingress interface is
 141          * not one of the egress interfaces, so trap these kind of routes.
 142          */
 143         if (mr_route->mr_table->ops->is_route_starg(mr_route->mr_table,
 144                                                     mr_route) &&
 145             !mlxsw_sp_mr_route_ivif_in_evifs(mr_route))
 146                 return MLXSW_SP_MR_ROUTE_ACTION_TRAP;
 147
 148         /* If the route has no valid eVIFs, trap it. */
 149         if (!mlxsw_sp_mr_route_valid_evifs_num(mr_route))
 150                 return MLXSW_SP_MR_ROUTE_ACTION_TRAP;
 151
 152         /* If one of the eVIFs has no RIF, trap-and-forward the route as there
 153          * is some more routing to do in software too.
 154          */
 155         list_for_each_entry(rve, &mr_route->evif_list, route_node)
 156                 if (mlxsw_sp_mr_vif_exists(rve->mr_vif) && !rve->mr_vif->rif)
 157                         return MLXSW_SP_MR_ROUTE_ACTION_TRAP_AND_FORWARD;
 158
 159         return MLXSW_SP_MR_ROUTE_ACTION_FORWARD;
 160 }
 161
 162 static enum mlxsw_sp_mr_route_prio
 163 mlxsw_sp_mr_route_prio(const struct mlxsw_sp_mr_route *mr_route)
 164 {
 165         return mr_route->mr_table->ops->is_route_starg(mr_route->mr_table,
 166                                                        mr_route) ?
 167                 MLXSW_SP_MR_ROUTE_PRIO_STARG : MLXSW_SP_MR_ROUTE_PRIO_SG;
 168 }
 169
 170 static int mlxsw_sp_mr_route_evif_link(struct mlxsw_sp_mr_route *mr_route,
 171                                        struct mlxsw_sp_mr_vif *mr_vif)
 172 {
 173         struct mlxsw_sp_mr_route_vif_entry *rve;
 174
 175         rve = kzalloc(sizeof(*rve), GFP_KERNEL);
 176         if (!rve)
 177                 return -ENOMEM;
 178         rve->mr_route = mr_route;
 179         rve->mr_vif = mr_vif;
 180         list_add_tail(&rve->route_node, &mr_route->evif_list);
 181         list_add_tail(&rve->vif_node, &mr_vif->route_evif_list);
 182         return 0;
 183 }
 184
 185 static void
 186 mlxsw_sp_mr_route_evif_unlink(struct mlxsw_sp_mr_route_vif_entry *rve)
 187 {
 188         list_del(&rve->route_node);
 189         list_del(&rve->vif_node);
 190         kfree(rve);
 191 }
 192
 193 static void mlxsw_sp_mr_route_ivif_link(struct mlxsw_sp_mr_route *mr_route,
 194                                         struct mlxsw_sp_mr_vif *mr_vif)
 195 {
 196         mr_route->ivif.mr_route = mr_route;
 197         mr_route->ivif.mr_vif = mr_vif;
 198         list_add_tail(&mr_route->ivif.vif_node, &mr_vif->route_ivif_list);
 199 }
 200
 201 static void mlxsw_sp_mr_route_ivif_unlink(struct mlxsw_sp_mr_route *mr_route)
 202 {
 203         list_del(&mr_route->ivif.vif_node);
 204 }
 205
 206 static int
 207 mlxsw_sp_mr_route_info_create(struct mlxsw_sp_mr_table *mr_table,
 208                               struct mlxsw_sp_mr_route *mr_route,
 209                               struct mlxsw_sp_mr_route_info *route_info)
 210 {
 211         struct mlxsw_sp_mr_route_vif_entry *rve;
 212         u16 *erif_indices;
 213         u16 irif_index;
 214         u16 erif = 0;
 215
 216         erif_indices = kmalloc_array(MAXVIFS, sizeof(*erif_indices),
 217                                      GFP_KERNEL);
 218         if (!erif_indices)
 219                 return -ENOMEM;
 220
 221         list_for_each_entry(rve, &mr_route->evif_list, route_node) {
 222                 if (mlxsw_sp_mr_vif_valid(rve->mr_vif)) {
 223                         u16 rifi = mlxsw_sp_rif_index(rve->mr_vif->rif);
 224
 225                         erif_indices[erif++] = rifi;
 226                 }
 227         }
 228
 229         if (mlxsw_sp_mr_vif_valid(mr_route->ivif.mr_vif))
 230                 irif_index = mlxsw_sp_rif_index(mr_route->ivif.mr_vif->rif);
 231         else
 232                 irif_index = 0;
 233
 234         route_info->irif_index = irif_index;
 235         route_info->erif_indices = erif_indices;
 236         route_info->min_mtu = mr_route->min_mtu;
 237         route_info->route_action = mr_route->route_action;
 238         route_info->erif_num = erif;
 239         return 0;
 240 }
 241
 242 static void
 243 mlxsw_sp_mr_route_info_destroy(struct mlxsw_sp_mr_route_info *route_info)
 244 {
 245         kfree(route_info->erif_indices);
 246 }
 247
 248 static int mlxsw_sp_mr_route_write(struct mlxsw_sp_mr_table *mr_table,
 249                                    struct mlxsw_sp_mr_route *mr_route,
 250                                    bool replace)
 251 {
 252         struct mlxsw_sp *mlxsw_sp = mr_table->mlxsw_sp;
 253         struct mlxsw_sp_mr_route_info route_info;
 254         struct mlxsw_sp_mr *mr = mlxsw_sp->mr;
 255         int err;
 256
 257         err = mlxsw_sp_mr_route_info_create(mr_table, mr_route, &route_info);
 258         if (err)
 259                 return err;
 260
 261         if (!replace) {
 262                 struct mlxsw_sp_mr_route_params route_params;
 263
 264                 mr_route->route_priv = kzalloc(mr->mr_ops->route_priv_size,
 265                                                GFP_KERNEL);
 266                 if (!mr_route->route_priv) {
 267                         err = -ENOMEM;
 268                         goto out;
 269                 }
 270
 271                 route_params.key = mr_route->key;
 272                 route_params.value = route_info;
 273                 route_params.prio = mlxsw_sp_mr_route_prio(mr_route);
 274                 err = mr->mr_ops->route_create(mlxsw_sp, mr->priv,
 275                                                mr_route->route_priv,
 276                                                &route_params);
 277                 if (err)
 278                         kfree(mr_route->route_priv);
 279         } else {
 280                 err = mr->mr_ops->route_update(mlxsw_sp, mr_route->route_priv,
 281                                                &route_info);
 282         }
 283 out:
 284         mlxsw_sp_mr_route_info_destroy(&route_info);
 285         return err;
 286 }
 287
 288 static void mlxsw_sp_mr_route_erase(struct mlxsw_sp_mr_table *mr_table,
 289                                     struct mlxsw_sp_mr_route *mr_route)
 290 {
 291         struct mlxsw_sp *mlxsw_sp = mr_table->mlxsw_sp;
 292         struct mlxsw_sp_mr *mr = mlxsw_sp->mr;
 293
 294         mr->mr_ops->route_destroy(mlxsw_sp, mr->priv, mr_route->route_priv);
 295         kfree(mr_route->route_priv);
 296 }
 297
 298 static struct mlxsw_sp_mr_route *
 299 mlxsw_sp_mr_route_create(struct mlxsw_sp_mr_table *mr_table,
 300                          struct mr_mfc *mfc)
 301 {
 302         struct mlxsw_sp_mr_route_vif_entry *rve, *tmp;
 303         struct mlxsw_sp_mr_route *mr_route;
 304         int err = 0;
 305         int i;
 306
 307         /* Allocate and init a new route and fill it with parameters */
 308         mr_route = kzalloc(sizeof(*mr_route), GFP_KERNEL);
 309         if (!mr_route)
 310                 return ERR_PTR(-ENOMEM);
 311         INIT_LIST_HEAD(&mr_route->evif_list);
 312
 313         /* Find min_mtu and link iVIF and eVIFs */
 314         mr_route->min_mtu = ETH_MAX_MTU;
 315         mr_cache_hold(mfc);
 316         mr_route->mfc = mfc;
 317         mr_table->ops->key_create(mr_table, &mr_route->key, mr_route->mfc);
 318
 319         mr_route->mr_table = mr_table;
 320         for (i = 0; i < MAXVIFS; i++) {
 321                 if (mfc->mfc_un.res.ttls[i] != 255) {
 322                         err = mlxsw_sp_mr_route_evif_link(mr_route,
 323                                                           &mr_table->vifs[i]);
 324                         if (err)
 325                                 goto err;
 326                         if (mr_table->vifs[i].dev &&
 327                             mr_table->vifs[i].dev->mtu < mr_route->min_mtu)
 328                                 mr_route->min_mtu = mr_table->vifs[i].dev->mtu;
 329                 }
 330         }
 331         mlxsw_sp_mr_route_ivif_link(mr_route,
 332                                     &mr_table->vifs[mfc->mfc_parent]);
 333
 334         mr_route->route_action = mlxsw_sp_mr_route_action(mr_route);
 335         return mr_route;
 336 err:
 337         mr_cache_put(mfc);
 338         list_for_each_entry_safe(rve, tmp, &mr_route->evif_list, route_node)
 339                 mlxsw_sp_mr_route_evif_unlink(rve);
 340         kfree(mr_route);
 341         return ERR_PTR(err);
 342 }
 343
 344 static void mlxsw_sp_mr_route_destroy(struct mlxsw_sp_mr_table *mr_table,
 345                                       struct mlxsw_sp_mr_route *mr_route)
 346 {
 347         struct mlxsw_sp_mr_route_vif_entry *rve, *tmp;
 348
 349         mlxsw_sp_mr_route_ivif_unlink(mr_route);
 350         mr_cache_put(mr_route->mfc);
 351         list_for_each_entry_safe(rve, tmp, &mr_route->evif_list, route_node)
 352                 mlxsw_sp_mr_route_evif_unlink(rve);
 353         kfree(mr_route);
 354 }
 355
 356 static void mlxsw_sp_mr_mfc_offload_set(struct mlxsw_sp_mr_route *mr_route,
 357                                         bool offload)
 358 {
 359         if (offload)
 360                 mr_route->mfc->mfc_flags |= MFC_OFFLOAD;
 361         else
 362                 mr_route->mfc->mfc_flags &= ~MFC_OFFLOAD;
 363 }
 364
 365 static void mlxsw_sp_mr_mfc_offload_update(struct mlxsw_sp_mr_route *mr_route)
 366 {
 367         bool offload;
 368
 369         offload = mr_route->route_action != MLXSW_SP_MR_ROUTE_ACTION_TRAP;
 370         mlxsw_sp_mr_mfc_offload_set(mr_route, offload);
 371 }
 372
 373 static void __mlxsw_sp_mr_route_del(struct mlxsw_sp_mr_table *mr_table,
 374                                     struct mlxsw_sp_mr_route *mr_route)
 375 {
 376         WARN_ON_ONCE(!mutex_is_locked(&mr_table->route_list_lock));
 377
 378         mlxsw_sp_mr_mfc_offload_set(mr_route, false);
 379         rhashtable_remove_fast(&mr_table->route_ht, &mr_route->ht_node,
 380                                mlxsw_sp_mr_route_ht_params);
 381         list_del(&mr_route->node);
 382         mlxsw_sp_mr_route_erase(mr_table, mr_route);
 383         mlxsw_sp_mr_route_destroy(mr_table, mr_route);
 384 }
 385
 386 int mlxsw_sp_mr_route_add(struct mlxsw_sp_mr_table *mr_table,
 387                           struct mr_mfc *mfc, bool replace)
 388 {
 389         struct mlxsw_sp_mr_route *mr_orig_route = NULL;
 390         struct mlxsw_sp_mr_route *mr_route;
 391         int err;
 392
 393         if (!mr_table->ops->is_route_valid(mr_table, mfc))
 394                 return -EINVAL;
 395
 396         /* Create a new route */
 397         mr_route = mlxsw_sp_mr_route_create(mr_table, mfc);
 398         if (IS_ERR(mr_route))
 399                 return PTR_ERR(mr_route);
 400
 401         /* Find any route with a matching key */
 402         mr_orig_route = rhashtable_lookup_fast(&mr_table->route_ht,
 403                                                &mr_route->key,
 404                                                mlxsw_sp_mr_route_ht_params);
 405         if (replace) {
 406                 /* On replace case, make the route point to the new route_priv.
 407                  */
 408                 if (WARN_ON(!mr_orig_route)) {
 409                         err = -ENOENT;
 410                         goto err_no_orig_route;
 411                 }
 412                 mr_route->route_priv = mr_orig_route->route_priv;
 413         } else if (mr_orig_route) {
 414                 /* On non replace case, if another route with the same key was
 415                  * found, abort, as duplicate routes are used for proxy routes.
 416                  */
 417                 dev_warn(mr_table->mlxsw_sp->bus_info->dev,
 418                          "Offloading proxy routes is not supported.\n");
 419                 err = -EINVAL;
 420                 goto err_duplicate_route;
 421         }
 422
 423         /* Write the route to the hardware */
 424         err = mlxsw_sp_mr_route_write(mr_table, mr_route, replace);
 425         if (err)
 426                 goto err_mr_route_write;
 427
 428         /* Put it in the table data-structures */
 429         mutex_lock(&mr_table->route_list_lock);
 430         list_add_tail(&mr_route->node, &mr_table->route_list);
 431         mutex_unlock(&mr_table->route_list_lock);
 432         err = rhashtable_insert_fast(&mr_table->route_ht,
 433                                      &mr_route->ht_node,
 434                                      mlxsw_sp_mr_route_ht_params);
 435         if (err)
 436                 goto err_rhashtable_insert;
 437
 438         /* Destroy the original route */
 439         if (replace) {
 440                 rhashtable_remove_fast(&mr_table->route_ht,
 441                                        &mr_orig_route->ht_node,
 442                                        mlxsw_sp_mr_route_ht_params);
 443                 list_del(&mr_orig_route->node);
 444                 mlxsw_sp_mr_route_destroy(mr_table, mr_orig_route);
 445         }
 446
 447         mlxsw_sp_mr_mfc_offload_update(mr_route);
 448         return 0;
 449
 450 err_rhashtable_insert:
 451         mutex_lock(&mr_table->route_list_lock);
 452         list_del(&mr_route->node);
 453         mutex_unlock(&mr_table->route_list_lock);
 454         mlxsw_sp_mr_route_erase(mr_table, mr_route);
 455 err_mr_route_write:
 456 err_no_orig_route:
 457 err_duplicate_route:
 458         mlxsw_sp_mr_route_destroy(mr_table, mr_route);
 459         return err;
 460 }
 461
 462 void mlxsw_sp_mr_route_del(struct mlxsw_sp_mr_table *mr_table,
 463                            struct mr_mfc *mfc)
 464 {
 465         struct mlxsw_sp_mr_route *mr_route;
 466         struct mlxsw_sp_mr_route_key key;
 467
 468         mr_table->ops->key_create(mr_table, &key, mfc);
 469         mr_route = rhashtable_lookup_fast(&mr_table->route_ht, &key,
 470                                           mlxsw_sp_mr_route_ht_params);
 471         if (mr_route) {
 472                 mutex_lock(&mr_table->route_list_lock);
 473                 __mlxsw_sp_mr_route_del(mr_table, mr_route);
 474                 mutex_unlock(&mr_table->route_list_lock);
 475         }
 476 }
 477
 478 /* Should be called after the VIF struct is updated */
 479 static int
 480 mlxsw_sp_mr_route_ivif_resolve(struct mlxsw_sp_mr_table *mr_table,
 481                                struct mlxsw_sp_mr_route_vif_entry *rve)
 482 {
 483         struct mlxsw_sp *mlxsw_sp = mr_table->mlxsw_sp;
 484         enum mlxsw_sp_mr_route_action route_action;
 485         struct mlxsw_sp_mr *mr = mlxsw_sp->mr;
 486         u16 irif_index;
 487         int err;
 488
 489         route_action = mlxsw_sp_mr_route_action(rve->mr_route);
 490         if (route_action == MLXSW_SP_MR_ROUTE_ACTION_TRAP)
 491                 return 0;
 492
 493         /* rve->mr_vif->rif is guaranteed to be valid at this stage */
 494         irif_index = mlxsw_sp_rif_index(rve->mr_vif->rif);
 495         err = mr->mr_ops->route_irif_update(mlxsw_sp, rve->mr_route->route_priv,
 496                                             irif_index);
 497         if (err)
 498                 return err;
 499
 500         err = mr->mr_ops->route_action_update(mlxsw_sp,
 501                                               rve->mr_route->route_priv,
 502                                               route_action);
 503         if (err)
 504                 /* No need to rollback here because the iRIF change only takes
 505                  * place after the action has been updated.
 506                  */
 507                 return err;
 508
 509         rve->mr_route->route_action = route_action;
 510         mlxsw_sp_mr_mfc_offload_update(rve->mr_route);
 511         return 0;
 512 }
 513
 514 static void
 515 mlxsw_sp_mr_route_ivif_unresolve(struct mlxsw_sp_mr_table *mr_table,
 516                                  struct mlxsw_sp_mr_route_vif_entry *rve)
 517 {
 518         struct mlxsw_sp *mlxsw_sp = mr_table->mlxsw_sp;
 519         struct mlxsw_sp_mr *mr = mlxsw_sp->mr;
 520
 521         mr->mr_ops->route_action_update(mlxsw_sp, rve->mr_route->route_priv,
 522                                         MLXSW_SP_MR_ROUTE_ACTION_TRAP);
 523         rve->mr_route->route_action = MLXSW_SP_MR_ROUTE_ACTION_TRAP;
 524         mlxsw_sp_mr_mfc_offload_update(rve->mr_route);
 525 }
 526
 527 /* Should be called after the RIF struct is updated */
 528 static int
 529 mlxsw_sp_mr_route_evif_resolve(struct mlxsw_sp_mr_table *mr_table,
 530                                struct mlxsw_sp_mr_route_vif_entry *rve)
 531 {
 532         struct mlxsw_sp *mlxsw_sp = mr_table->mlxsw_sp;
 533         enum mlxsw_sp_mr_route_action route_action;
 534         struct mlxsw_sp_mr *mr = mlxsw_sp->mr;
 535         u16 erif_index = 0;
 536         int err;
 537
 538         /* Update the route action, as the new eVIF can be a tunnel or a pimreg
 539          * device which will require updating the action.
 540          */
 541         route_action = mlxsw_sp_mr_route_action(rve->mr_route);
 542         if (route_action != rve->mr_route->route_action) {
 543                 err = mr->mr_ops->route_action_update(mlxsw_sp,
 544                                                       rve->mr_route->route_priv,
 545                                                       route_action);
 546                 if (err)
 547                         return err;
 548         }
 549
 550         /* Add the eRIF */
 551         if (mlxsw_sp_mr_vif_valid(rve->mr_vif)) {
 552                 erif_index = mlxsw_sp_rif_index(rve->mr_vif->rif);
 553                 err = mr->mr_ops->route_erif_add(mlxsw_sp,
 554                                                  rve->mr_route->route_priv,
 555                                                  erif_index);
 556                 if (err)
 557                         goto err_route_erif_add;
 558         }
 559
 560         /* Update the minimum MTU */
 561         if (rve->mr_vif->dev->mtu < rve->mr_route->min_mtu) {
 562                 rve->mr_route->min_mtu = rve->mr_vif->dev->mtu;
 563                 err = mr->mr_ops->route_min_mtu_update(mlxsw_sp,
 564                                                        rve->mr_route->route_priv,
 565                                                        rve->mr_route->min_mtu);
 566                 if (err)
 567                         goto err_route_min_mtu_update;
 568         }
 569
 570         rve->mr_route->route_action = route_action;
 571         mlxsw_sp_mr_mfc_offload_update(rve->mr_route);
 572         return 0;
 573
 574 err_route_min_mtu_update:
 575         if (mlxsw_sp_mr_vif_valid(rve->mr_vif))
 576                 mr->mr_ops->route_erif_del(mlxsw_sp, rve->mr_route->route_priv,
 577                                            erif_index);
 578 err_route_erif_add:
 579         if (route_action != rve->mr_route->route_action)
 580                 mr->mr_ops->route_action_update(mlxsw_sp,
 581                                                 rve->mr_route->route_priv,
 582                                                 rve->mr_route->route_action);
 583         return err;
 584 }
 585
 586 /* Should be called before the RIF struct is updated */
 587 static void
 588 mlxsw_sp_mr_route_evif_unresolve(struct mlxsw_sp_mr_table *mr_table,
 589                                  struct mlxsw_sp_mr_route_vif_entry *rve)
 590 {
 591         struct mlxsw_sp *mlxsw_sp = mr_table->mlxsw_sp;
 592         enum mlxsw_sp_mr_route_action route_action;
 593         struct mlxsw_sp_mr *mr = mlxsw_sp->mr;
 594         u16 rifi;
 595
 596         /* If the unresolved RIF was not valid, no need to delete it */
 597         if (!mlxsw_sp_mr_vif_valid(rve->mr_vif))
 598                 return;
 599
 600         /* Update the route action: if there is only one valid eVIF in the
 601          * route, set the action to trap as the VIF deletion will lead to zero
 602          * valid eVIFs. On any other case, use the mlxsw_sp_mr_route_action to
 603          * determine the route action.
 604          */
 605         if (mlxsw_sp_mr_route_valid_evifs_num(rve->mr_route) == 1)
 606                 route_action = MLXSW_SP_MR_ROUTE_ACTION_TRAP;
 607         else
 608                 route_action = mlxsw_sp_mr_route_action(rve->mr_route);
 609         if (route_action != rve->mr_route->route_action)
 610                 mr->mr_ops->route_action_update(mlxsw_sp,
 611                                                 rve->mr_route->route_priv,
 612                                                 route_action);
 613
 614         /* Delete the erif from the route */
 615         rifi = mlxsw_sp_rif_index(rve->mr_vif->rif);
 616         mr->mr_ops->route_erif_del(mlxsw_sp, rve->mr_route->route_priv, rifi);
 617         rve->mr_route->route_action = route_action;
 618         mlxsw_sp_mr_mfc_offload_update(rve->mr_route);
 619 }
 620
 621 static int mlxsw_sp_mr_vif_resolve(struct mlxsw_sp_mr_table *mr_table,
 622                                    struct net_device *dev,
 623                                    struct mlxsw_sp_mr_vif *mr_vif,
 624                                    unsigned long vif_flags,
 625                                    const struct mlxsw_sp_rif *rif)
 626 {
 627         struct mlxsw_sp_mr_route_vif_entry *irve, *erve;
 628         int err;
 629
 630         /* Update the VIF */
 631         mr_vif->dev = dev;
 632         mr_vif->rif = rif;
 633         mr_vif->vif_flags = vif_flags;
 634
 635         /* Update all routes where this VIF is used as an unresolved iRIF */
 636         list_for_each_entry(irve, &mr_vif->route_ivif_list, vif_node) {
 637                 err = mlxsw_sp_mr_route_ivif_resolve(mr_table, irve);
 638                 if (err)
 639                         goto err_irif_unresolve;
 640         }
 641
 642         /* Update all routes where this VIF is used as an unresolved eRIF */
 643         list_for_each_entry(erve, &mr_vif->route_evif_list, vif_node) {
 644                 err = mlxsw_sp_mr_route_evif_resolve(mr_table, erve);
 645                 if (err)
 646                         goto err_erif_unresolve;
 647         }
 648         return 0;
 649
 650 err_erif_unresolve:
 651         list_for_each_entry_continue_reverse(erve, &mr_vif->route_evif_list,
 652                                              vif_node)
 653                 mlxsw_sp_mr_route_evif_unresolve(mr_table, erve);
 654 err_irif_unresolve:
 655         list_for_each_entry_continue_reverse(irve, &mr_vif->route_ivif_list,
 656                                              vif_node)
 657                 mlxsw_sp_mr_route_ivif_unresolve(mr_table, irve);
 658         mr_vif->rif = NULL;
 659         return err;
 660 }
 661
 662 static void mlxsw_sp_mr_vif_unresolve(struct mlxsw_sp_mr_table *mr_table,
 663                                       struct net_device *dev,
 664                                       struct mlxsw_sp_mr_vif *mr_vif)
 665 {
 666         struct mlxsw_sp_mr_route_vif_entry *rve;
 667
 668         /* Update all routes where this VIF is used as an unresolved eRIF */
 669         list_for_each_entry(rve, &mr_vif->route_evif_list, vif_node)
 670                 mlxsw_sp_mr_route_evif_unresolve(mr_table, rve);
 671
 672         /* Update all routes where this VIF is used as an unresolved iRIF */
 673         list_for_each_entry(rve, &mr_vif->route_ivif_list, vif_node)
 674                 mlxsw_sp_mr_route_ivif_unresolve(mr_table, rve);
 675
 676         /* Update the VIF */
 677         mr_vif->dev = dev;
 678         mr_vif->rif = NULL;
 679 }
 680
 681 int mlxsw_sp_mr_vif_add(struct mlxsw_sp_mr_table *mr_table,
 682                         struct net_device *dev, vifi_t vif_index,
 683                         unsigned long vif_flags, const struct mlxsw_sp_rif *rif)
 684 {
 685         struct mlxsw_sp_mr_vif *mr_vif = &mr_table->vifs[vif_index];
 686
 687         if (WARN_ON(vif_index >= MAXVIFS))
 688                 return -EINVAL;
 689         if (mr_vif->dev)
 690                 return -EEXIST;
 691         return mlxsw_sp_mr_vif_resolve(mr_table, dev, mr_vif, vif_flags, rif);
 692 }
 693
 694 void mlxsw_sp_mr_vif_del(struct mlxsw_sp_mr_table *mr_table, vifi_t vif_index)
 695 {
 696         struct mlxsw_sp_mr_vif *mr_vif = &mr_table->vifs[vif_index];
 697
 698         if (WARN_ON(vif_index >= MAXVIFS))
 699                 return;
 700         if (WARN_ON(!mr_vif->dev))
 701                 return;
 702         mlxsw_sp_mr_vif_unresolve(mr_table, NULL, mr_vif);
 703 }
 704
 705 static struct mlxsw_sp_mr_vif *
 706 mlxsw_sp_mr_dev_vif_lookup(struct mlxsw_sp_mr_table *mr_table,
 707                            const struct net_device *dev)
 708 {
 709         vifi_t vif_index;
 710
 711         for (vif_index = 0; vif_index < MAXVIFS; vif_index++)
 712                 if (mr_table->vifs[vif_index].dev == dev)
 713                         return &mr_table->vifs[vif_index];
 714         return NULL;
 715 }
 716
 717 int mlxsw_sp_mr_rif_add(struct mlxsw_sp_mr_table *mr_table,
 718                         const struct mlxsw_sp_rif *rif)
 719 {
 720         const struct net_device *rif_dev = mlxsw_sp_rif_dev(rif);
 721         struct mlxsw_sp_mr_vif *mr_vif;
 722
 723         if (!rif_dev)
 724                 return 0;
 725
 726         mr_vif = mlxsw_sp_mr_dev_vif_lookup(mr_table, rif_dev);
 727         if (!mr_vif)
 728                 return 0;
 729         return mlxsw_sp_mr_vif_resolve(mr_table, mr_vif->dev, mr_vif,
 730                                        mr_vif->vif_flags, rif);
 731 }
 732
 733 void mlxsw_sp_mr_rif_del(struct mlxsw_sp_mr_table *mr_table,
 734                          const struct mlxsw_sp_rif *rif)
 735 {
 736         const struct net_device *rif_dev = mlxsw_sp_rif_dev(rif);
 737         struct mlxsw_sp_mr_vif *mr_vif;
 738
 739         if (!rif_dev)
 740                 return;
 741
 742         mr_vif = mlxsw_sp_mr_dev_vif_lookup(mr_table, rif_dev);
 743         if (!mr_vif)
 744                 return;
 745         mlxsw_sp_mr_vif_unresolve(mr_table, mr_vif->dev, mr_vif);
 746 }
 747
 748 void mlxsw_sp_mr_rif_mtu_update(struct mlxsw_sp_mr_table *mr_table,
 749                                 const struct mlxsw_sp_rif *rif, int mtu)
 750 {
 751         const struct net_device *rif_dev = mlxsw_sp_rif_dev(rif);
 752         struct mlxsw_sp *mlxsw_sp = mr_table->mlxsw_sp;
 753         struct mlxsw_sp_mr_route_vif_entry *rve;
 754         struct mlxsw_sp_mr *mr = mlxsw_sp->mr;
 755         struct mlxsw_sp_mr_vif *mr_vif;
 756
 757         if (!rif_dev)
 758                 return;
 759
 760         /* Search for a VIF that use that RIF */
 761         mr_vif = mlxsw_sp_mr_dev_vif_lookup(mr_table, rif_dev);
 762         if (!mr_vif)
 763                 return;
 764
 765         /* Update all the routes that uses that VIF as eVIF */
 766         list_for_each_entry(rve, &mr_vif->route_evif_list, vif_node) {
 767                 if (mtu < rve->mr_route->min_mtu) {
 768                         rve->mr_route->min_mtu = mtu;
 769                         mr->mr_ops->route_min_mtu_update(mlxsw_sp,
 770                                                          rve->mr_route->route_priv,
 771                                                          mtu);
 772                 }
 773         }
 774 }
 775
 776 /* Protocol specific functions */
 777 static bool
 778 mlxsw_sp_mr_route4_validate(const struct mlxsw_sp_mr_table *mr_table,
 779                             const struct mr_mfc *c)
 780 {
 781         struct mfc_cache *mfc = (struct mfc_cache *) c;
 782
 783         /* If the route is a (*,*) route, abort, as these kind of routes are
 784          * used for proxy routes.
 785          */
 786         if (mfc->mfc_origin == htonl(INADDR_ANY) &&
 787             mfc->mfc_mcastgrp == htonl(INADDR_ANY)) {
 788                 dev_warn(mr_table->mlxsw_sp->bus_info->dev,
 789                          "Offloading proxy routes is not supported.\n");
 790                 return false;
 791         }
 792         return true;
 793 }
 794
 795 static void mlxsw_sp_mr_route4_key(struct mlxsw_sp_mr_table *mr_table,
 796                                    struct mlxsw_sp_mr_route_key *key,
 797                                    struct mr_mfc *c)
 798 {
 799         const struct mfc_cache *mfc = (struct mfc_cache *) c;
 800         bool starg;
 801
 802         starg = (mfc->mfc_origin == htonl(INADDR_ANY));
 803
 804         memset(key, 0, sizeof(*key));
 805         key->vrid = mr_table->vr_id;
 806         key->proto = MLXSW_SP_L3_PROTO_IPV4;
 807         key->group.addr4 = mfc->mfc_mcastgrp;
 808         key->group_mask.addr4 = htonl(0xffffffff);
 809         key->source.addr4 = mfc->mfc_origin;
 810         key->source_mask.addr4 = htonl(starg ? 0 : 0xffffffff);
 811 }
 812
 813 static bool mlxsw_sp_mr_route4_starg(const struct mlxsw_sp_mr_table *mr_table,
 814                                      const struct mlxsw_sp_mr_route *mr_route)
 815 {
 816         return mr_route->key.source_mask.addr4 == htonl(INADDR_ANY);
 817 }
 818
 819 static bool mlxsw_sp_mr_vif4_is_regular(const struct mlxsw_sp_mr_vif *vif)
 820 {
 821         return !(vif->vif_flags & (VIFF_TUNNEL | VIFF_REGISTER));
 822 }
 823
 824 static bool
 825 mlxsw_sp_mr_route6_validate(const struct mlxsw_sp_mr_table *mr_table,
 826                             const struct mr_mfc *c)
 827 {
 828         struct mfc6_cache *mfc = (struct mfc6_cache *) c;
 829
 830         /* If the route is a (*,*) route, abort, as these kind of routes are
 831          * used for proxy routes.
 832          */
 833         if (ipv6_addr_any(&mfc->mf6c_origin) &&
 834             ipv6_addr_any(&mfc->mf6c_mcastgrp)) {
 835                 dev_warn(mr_table->mlxsw_sp->bus_info->dev,
 836                          "Offloading proxy routes is not supported.\n");
 837                 return false;
 838         }
 839         return true;
 840 }
 841
 842 static void mlxsw_sp_mr_route6_key(struct mlxsw_sp_mr_table *mr_table,
 843                                    struct mlxsw_sp_mr_route_key *key,
 844                                    struct mr_mfc *c)
 845 {
 846         const struct mfc6_cache *mfc = (struct mfc6_cache *) c;
 847
 848         memset(key, 0, sizeof(*key));
 849         key->vrid = mr_table->vr_id;
 850         key->proto = MLXSW_SP_L3_PROTO_IPV6;
 851         key->group.addr6 = mfc->mf6c_mcastgrp;
 852         memset(&key->group_mask.addr6, 0xff, sizeof(key->group_mask.addr6));
 853         key->source.addr6 = mfc->mf6c_origin;
 854         if (!ipv6_addr_any(&mfc->mf6c_origin))
 855                 memset(&key->source_mask.addr6, 0xff,
 856                        sizeof(key->source_mask.addr6));
 857 }
 858
 859 static bool mlxsw_sp_mr_route6_starg(const struct mlxsw_sp_mr_table *mr_table,
 860                                      const struct mlxsw_sp_mr_route *mr_route)
 861 {
 862         return ipv6_addr_any(&mr_route->key.source_mask.addr6);
 863 }
 864
 865 static bool mlxsw_sp_mr_vif6_is_regular(const struct mlxsw_sp_mr_vif *vif)
 866 {
 867         return !(vif->vif_flags & MIFF_REGISTER);
 868 }
 869
 870 static struct
 871 mlxsw_sp_mr_vif_ops mlxsw_sp_mr_vif_ops_arr[] = {
 872         {
 873                 .is_regular = mlxsw_sp_mr_vif4_is_regular,
 874         },
 875         {
 876                 .is_regular = mlxsw_sp_mr_vif6_is_regular,
 877         },
 878 };
 879
 880 static struct
 881 mlxsw_sp_mr_table_ops mlxsw_sp_mr_table_ops_arr[] = {
 882         {
 883                 .is_route_valid = mlxsw_sp_mr_route4_validate,
 884                 .key_create = mlxsw_sp_mr_route4_key,
 885                 .is_route_starg = mlxsw_sp_mr_route4_starg,
 886         },
 887         {
 888                 .is_route_valid = mlxsw_sp_mr_route6_validate,
 889                 .key_create = mlxsw_sp_mr_route6_key,
 890                 .is_route_starg = mlxsw_sp_mr_route6_starg,
 891         },
 892
 893 };
 894
 895 struct mlxsw_sp_mr_table *mlxsw_sp_mr_table_create(struct mlxsw_sp *mlxsw_sp,
 896                                                    u32 vr_id,
 897                                                    enum mlxsw_sp_l3proto proto)
 898 {
 899         struct mlxsw_sp_mr_route_params catchall_route_params = {
 900                 .prio = MLXSW_SP_MR_ROUTE_PRIO_CATCHALL,
 901                 .key = {
 902                         .vrid = vr_id,
 903                         .proto = proto,
 904                 },
 905                 .value = {
 906                         .route_action = MLXSW_SP_MR_ROUTE_ACTION_TRAP,
 907                 }
 908         };
 909         struct mlxsw_sp_mr *mr = mlxsw_sp->mr;
 910         struct mlxsw_sp_mr_table *mr_table;
 911         int err;
 912         int i;
 913
 914         mr_table = kzalloc(sizeof(*mr_table) + mr->mr_ops->route_priv_size,
 915                            GFP_KERNEL);
 916         if (!mr_table)
 917                 return ERR_PTR(-ENOMEM);
 918
 919         mr_table->vr_id = vr_id;
 920         mr_table->mlxsw_sp = mlxsw_sp;
 921         mr_table->proto = proto;
 922         mr_table->ops = &mlxsw_sp_mr_table_ops_arr[proto];
 923         INIT_LIST_HEAD(&mr_table->route_list);
 924         mutex_init(&mr_table->route_list_lock);
 925
 926         err = rhashtable_init(&mr_table->route_ht,
 927                               &mlxsw_sp_mr_route_ht_params);
 928         if (err)
 929                 goto err_route_rhashtable_init;
 930
 931         for (i = 0; i < MAXVIFS; i++) {
 932                 INIT_LIST_HEAD(&mr_table->vifs[i].route_evif_list);
 933                 INIT_LIST_HEAD(&mr_table->vifs[i].route_ivif_list);
 934                 mr_table->vifs[i].ops = &mlxsw_sp_mr_vif_ops_arr[proto];
 935         }
 936
 937         err = mr->mr_ops->route_create(mlxsw_sp, mr->priv,
 938                                        mr_table->catchall_route_priv,
 939                                        &catchall_route_params);
 940         if (err)
 941                 goto err_ops_route_create;
 942         mutex_lock(&mr->table_list_lock);
 943         list_add_tail(&mr_table->node, &mr->table_list);
 944         mutex_unlock(&mr->table_list_lock);
 945         return mr_table;
 946
 947 err_ops_route_create:
 948         rhashtable_destroy(&mr_table->route_ht);
 949 err_route_rhashtable_init:
 950         mutex_destroy(&mr_table->route_list_lock);
 951         kfree(mr_table);
 952         return ERR_PTR(err);
 953 }
 954
 955 void mlxsw_sp_mr_table_destroy(struct mlxsw_sp_mr_table *mr_table)
 956 {
 957         struct mlxsw_sp *mlxsw_sp = mr_table->mlxsw_sp;
 958         struct mlxsw_sp_mr *mr = mlxsw_sp->mr;
 959
 960         WARN_ON(!mlxsw_sp_mr_table_empty(mr_table));
 961         mutex_lock(&mr->table_list_lock);
 962         list_del(&mr_table->node);
 963         mutex_unlock(&mr->table_list_lock);
 964         mr->mr_ops->route_destroy(mlxsw_sp, mr->priv,
 965                                   &mr_table->catchall_route_priv);
 966         rhashtable_destroy(&mr_table->route_ht);
 967         mutex_destroy(&mr_table->route_list_lock);
 968         kfree(mr_table);
 969 }
 970
 971 void mlxsw_sp_mr_table_flush(struct mlxsw_sp_mr_table *mr_table)
 972 {
 973         struct mlxsw_sp_mr_route *mr_route, *tmp;
 974         int i;
 975
 976         mutex_lock(&mr_table->route_list_lock);
 977         list_for_each_entry_safe(mr_route, tmp, &mr_table->route_list, node)
 978                 __mlxsw_sp_mr_route_del(mr_table, mr_route);
 979         mutex_unlock(&mr_table->route_list_lock);
 980
 981         for (i = 0; i < MAXVIFS; i++) {
 982                 mr_table->vifs[i].dev = NULL;
 983                 mr_table->vifs[i].rif = NULL;
 984         }
 985 }
 986
 987 bool mlxsw_sp_mr_table_empty(const struct mlxsw_sp_mr_table *mr_table)
 988 {
 989         int i;
 990
 991         for (i = 0; i < MAXVIFS; i++)
 992                 if (mr_table->vifs[i].dev)
 993                         return false;
 994         return list_empty(&mr_table->route_list);
 995 }
 996
 997 static void mlxsw_sp_mr_route_stats_update(struct mlxsw_sp *mlxsw_sp,
 998                                            struct mlxsw_sp_mr_route *mr_route)
 999 {
1000         struct mlxsw_sp_mr *mr = mlxsw_sp->mr;
1001         u64 packets, bytes;
1002
1003         if (mr_route->route_action == MLXSW_SP_MR_ROUTE_ACTION_TRAP)
1004                 return;
1005
1006         mr->mr_ops->route_stats(mlxsw_sp, mr_route->route_priv, &packets,
1007                                 &bytes);
1008
1009         if (mr_route->mfc->mfc_un.res.pkt != packets)
1010                 mr_route->mfc->mfc_un.res.lastuse = jiffies;
1011         mr_route->mfc->mfc_un.res.pkt = packets;
1012         mr_route->mfc->mfc_un.res.bytes = bytes;
1013 }
1014
1015 static void mlxsw_sp_mr_stats_update(struct work_struct *work)
1016 {
1017         struct mlxsw_sp_mr *mr = container_of(work, struct mlxsw_sp_mr,
1018                                               stats_update_dw.work);
1019         struct mlxsw_sp_mr_table *mr_table;
1020         struct mlxsw_sp_mr_route *mr_route;
1021         unsigned long interval;
1022
1023         mutex_lock(&mr->table_list_lock);
1024         list_for_each_entry(mr_table, &mr->table_list, node) {
1025                 mutex_lock(&mr_table->route_list_lock);
1026                 list_for_each_entry(mr_route, &mr_table->route_list, node)
1027                         mlxsw_sp_mr_route_stats_update(mr_table->mlxsw_sp,
1028                                                        mr_route);
1029                 mutex_unlock(&mr_table->route_list_lock);
1030         }
1031         mutex_unlock(&mr->table_list_lock);
1032
1033         interval = msecs_to_jiffies(MLXSW_SP_MR_ROUTES_COUNTER_UPDATE_INTERVAL);
1034         mlxsw_core_schedule_dw(&mr->stats_update_dw, interval);
1035 }
1036
1037 int mlxsw_sp_mr_init(struct mlxsw_sp *mlxsw_sp,
1038                      const struct mlxsw_sp_mr_ops *mr_ops)
1039 {
1040         struct mlxsw_sp_mr *mr;
1041         unsigned long interval;
1042         int err;
1043
1044         mr = kzalloc(sizeof(*mr) + mr_ops->priv_size, GFP_KERNEL);
1045         if (!mr)
1046                 return -ENOMEM;
1047         mr->mr_ops = mr_ops;
1048         mlxsw_sp->mr = mr;
1049         INIT_LIST_HEAD(&mr->table_list);
1050         mutex_init(&mr->table_list_lock);
1051
1052         err = mr_ops->init(mlxsw_sp, mr->priv);
1053         if (err)
1054                 goto err;
1055
1056         /* Create the delayed work for counter updates */
1057         INIT_DELAYED_WORK(&mr->stats_update_dw, mlxsw_sp_mr_stats_update);
1058         interval = msecs_to_jiffies(MLXSW_SP_MR_ROUTES_COUNTER_UPDATE_INTERVAL);
1059         mlxsw_core_schedule_dw(&mr->stats_update_dw, interval);
1060         return 0;
1061 err:
1062         mutex_destroy(&mr->table_list_lock);
1063         kfree(mr);
1064         return err;
1065 }
1066
1067 void mlxsw_sp_mr_fini(struct mlxsw_sp *mlxsw_sp)
1068 {
1069         struct mlxsw_sp_mr *mr = mlxsw_sp->mr;
1070
1071         cancel_delayed_work_sync(&mr->stats_update_dw);
1072         mr->mr_ops->fini(mlxsw_sp, mr->priv);
1073         mutex_destroy(&mr->table_list_lock);
1074         kfree(mr);
1075 }