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

   1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
   2 /* Copyright (c) 2018 Mellanox Technologies. All rights reserved */
   3
   4 #include <linux/if_bridge.h>
   5 #include <linux/list.h>
   6 #include <net/arp.h>
   7 #include <net/gre.h>
   8 #include <net/lag.h>
   9 #include <net/ndisc.h>
  10 #include <net/ip6_tunnel.h>
  11
  12 #include "spectrum.h"
  13 #include "spectrum_ipip.h"
  14 #include "spectrum_span.h"
  15 #include "spectrum_switchdev.h"
  16
  17 int mlxsw_sp_span_init(struct mlxsw_sp *mlxsw_sp)
  18 {
  19         int i;
  20
  21         if (!MLXSW_CORE_RES_VALID(mlxsw_sp->core, MAX_SPAN))
  22                 return -EIO;
  23
  24         mlxsw_sp->span.entries_count = MLXSW_CORE_RES_GET(mlxsw_sp->core,
  25                                                           MAX_SPAN);
  26         mlxsw_sp->span.entries = kcalloc(mlxsw_sp->span.entries_count,
  27                                          sizeof(struct mlxsw_sp_span_entry),
  28                                          GFP_KERNEL);
  29         if (!mlxsw_sp->span.entries)
  30                 return -ENOMEM;
  31
  32         for (i = 0; i < mlxsw_sp->span.entries_count; i++) {
  33                 struct mlxsw_sp_span_entry *curr = &mlxsw_sp->span.entries[i];
  34
  35                 INIT_LIST_HEAD(&curr->bound_ports_list);
  36                 curr->id = i;
  37         }
  38
  39         return 0;
  40 }
  41
  42 void mlxsw_sp_span_fini(struct mlxsw_sp *mlxsw_sp)
  43 {
  44         int i;
  45
  46         for (i = 0; i < mlxsw_sp->span.entries_count; i++) {
  47                 struct mlxsw_sp_span_entry *curr = &mlxsw_sp->span.entries[i];
  48
  49                 WARN_ON_ONCE(!list_empty(&curr->bound_ports_list));
  50         }
  51         kfree(mlxsw_sp->span.entries);
  52 }
  53
  54 static int
  55 mlxsw_sp_span_entry_phys_parms(const struct net_device *to_dev,
  56                                struct mlxsw_sp_span_parms *sparmsp)
  57 {
  58         sparmsp->dest_port = netdev_priv(to_dev);
  59         return 0;
  60 }
  61
  62 static int
  63 mlxsw_sp_span_entry_phys_configure(struct mlxsw_sp_span_entry *span_entry,
  64                                    struct mlxsw_sp_span_parms sparms)
  65 {
  66         struct mlxsw_sp_port *dest_port = sparms.dest_port;
  67         struct mlxsw_sp *mlxsw_sp = dest_port->mlxsw_sp;
  68         u8 local_port = dest_port->local_port;
  69         char mpat_pl[MLXSW_REG_MPAT_LEN];
  70         int pa_id = span_entry->id;
  71
  72         /* Create a new port analayzer entry for local_port. */
  73         mlxsw_reg_mpat_pack(mpat_pl, pa_id, local_port, true,
  74                             MLXSW_REG_MPAT_SPAN_TYPE_LOCAL_ETH);
  75
  76         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(mpat), mpat_pl);
  77 }
  78
  79 static void
  80 mlxsw_sp_span_entry_deconfigure_common(struct mlxsw_sp_span_entry *span_entry,
  81                                        enum mlxsw_reg_mpat_span_type span_type)
  82 {
  83         struct mlxsw_sp_port *dest_port = span_entry->parms.dest_port;
  84         struct mlxsw_sp *mlxsw_sp = dest_port->mlxsw_sp;
  85         u8 local_port = dest_port->local_port;
  86         char mpat_pl[MLXSW_REG_MPAT_LEN];
  87         int pa_id = span_entry->id;
  88
  89         mlxsw_reg_mpat_pack(mpat_pl, pa_id, local_port, false, span_type);
  90         mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(mpat), mpat_pl);
  91 }
  92
  93 static void
  94 mlxsw_sp_span_entry_phys_deconfigure(struct mlxsw_sp_span_entry *span_entry)
  95 {
  96         mlxsw_sp_span_entry_deconfigure_common(span_entry,
  97                                             MLXSW_REG_MPAT_SPAN_TYPE_LOCAL_ETH);
  98 }
  99
 100 static const
 101 struct mlxsw_sp_span_entry_ops mlxsw_sp_span_entry_ops_phys = {
 102         .can_handle = mlxsw_sp_port_dev_check,
 103         .parms = mlxsw_sp_span_entry_phys_parms,
 104         .configure = mlxsw_sp_span_entry_phys_configure,
 105         .deconfigure = mlxsw_sp_span_entry_phys_deconfigure,
 106 };
 107
 108 static int mlxsw_sp_span_dmac(struct neigh_table *tbl,
 109                               const void *pkey,
 110                               struct net_device *dev,
 111                               unsigned char dmac[ETH_ALEN])
 112 {
 113         struct neighbour *neigh = neigh_lookup(tbl, pkey, dev);
 114         int err = 0;
 115
 116         if (!neigh) {
 117                 neigh = neigh_create(tbl, pkey, dev);
 118                 if (IS_ERR(neigh))
 119                         return PTR_ERR(neigh);
 120         }
 121
 122         neigh_event_send(neigh, NULL);
 123
 124         read_lock_bh(&neigh->lock);
 125         if ((neigh->nud_state & NUD_VALID) && !neigh->dead)
 126                 memcpy(dmac, neigh->ha, ETH_ALEN);
 127         else
 128                 err = -ENOENT;
 129         read_unlock_bh(&neigh->lock);
 130
 131         neigh_release(neigh);
 132         return err;
 133 }
 134
 135 static int
 136 mlxsw_sp_span_entry_unoffloadable(struct mlxsw_sp_span_parms *sparmsp)
 137 {
 138         sparmsp->dest_port = NULL;
 139         return 0;
 140 }
 141
 142 static struct net_device *
 143 mlxsw_sp_span_entry_bridge_8021q(const struct net_device *br_dev,
 144                                  unsigned char *dmac,
 145                                  u16 *p_vid)
 146 {
 147         struct bridge_vlan_info vinfo;
 148         struct net_device *edev;
 149         u16 vid = *p_vid;
 150
 151         if (!vid && WARN_ON(br_vlan_get_pvid(br_dev, &vid)))
 152                 return NULL;
 153         if (!vid ||
 154             br_vlan_get_info(br_dev, vid, &vinfo) ||
 155             !(vinfo.flags & BRIDGE_VLAN_INFO_BRENTRY))
 156                 return NULL;
 157
 158         edev = br_fdb_find_port(br_dev, dmac, vid);
 159         if (!edev)
 160                 return NULL;
 161
 162         if (br_vlan_get_info(edev, vid, &vinfo))
 163                 return NULL;
 164         if (vinfo.flags & BRIDGE_VLAN_INFO_UNTAGGED)
 165                 *p_vid = 0;
 166         else
 167                 *p_vid = vid;
 168         return edev;
 169 }
 170
 171 static struct net_device *
 172 mlxsw_sp_span_entry_bridge_8021d(const struct net_device *br_dev,
 173                                  unsigned char *dmac)
 174 {
 175         return br_fdb_find_port(br_dev, dmac, 0);
 176 }
 177
 178 static struct net_device *
 179 mlxsw_sp_span_entry_bridge(const struct net_device *br_dev,
 180                            unsigned char dmac[ETH_ALEN],
 181                            u16 *p_vid)
 182 {
 183         struct mlxsw_sp_bridge_port *bridge_port;
 184         enum mlxsw_reg_spms_state spms_state;
 185         struct net_device *dev = NULL;
 186         struct mlxsw_sp_port *port;
 187         u8 stp_state;
 188
 189         if (br_vlan_enabled(br_dev))
 190                 dev = mlxsw_sp_span_entry_bridge_8021q(br_dev, dmac, p_vid);
 191         else if (!*p_vid)
 192                 dev = mlxsw_sp_span_entry_bridge_8021d(br_dev, dmac);
 193         if (!dev)
 194                 return NULL;
 195
 196         port = mlxsw_sp_port_dev_lower_find(dev);
 197         if (!port)
 198                 return NULL;
 199
 200         bridge_port = mlxsw_sp_bridge_port_find(port->mlxsw_sp->bridge, dev);
 201         if (!bridge_port)
 202                 return NULL;
 203
 204         stp_state = mlxsw_sp_bridge_port_stp_state(bridge_port);
 205         spms_state = mlxsw_sp_stp_spms_state(stp_state);
 206         if (spms_state != MLXSW_REG_SPMS_STATE_FORWARDING)
 207                 return NULL;
 208
 209         return dev;
 210 }
 211
 212 static struct net_device *
 213 mlxsw_sp_span_entry_vlan(const struct net_device *vlan_dev,
 214                          u16 *p_vid)
 215 {
 216         *p_vid = vlan_dev_vlan_id(vlan_dev);
 217         return vlan_dev_real_dev(vlan_dev);
 218 }
 219
 220 static struct net_device *
 221 mlxsw_sp_span_entry_lag(struct net_device *lag_dev)
 222 {
 223         struct net_device *dev;
 224         struct list_head *iter;
 225
 226         netdev_for_each_lower_dev(lag_dev, dev, iter)
 227                 if (netif_carrier_ok(dev) &&
 228                     net_lag_port_dev_txable(dev) &&
 229                     mlxsw_sp_port_dev_check(dev))
 230                         return dev;
 231
 232         return NULL;
 233 }
 234
 235 static __maybe_unused int
 236 mlxsw_sp_span_entry_tunnel_parms_common(struct net_device *edev,
 237                                         union mlxsw_sp_l3addr saddr,
 238                                         union mlxsw_sp_l3addr daddr,
 239                                         union mlxsw_sp_l3addr gw,
 240                                         __u8 ttl,
 241                                         struct neigh_table *tbl,
 242                                         struct mlxsw_sp_span_parms *sparmsp)
 243 {
 244         unsigned char dmac[ETH_ALEN];
 245         u16 vid = 0;
 246
 247         if (mlxsw_sp_l3addr_is_zero(gw))
 248                 gw = daddr;
 249
 250         if (!edev || mlxsw_sp_span_dmac(tbl, &gw, edev, dmac))
 251                 goto unoffloadable;
 252
 253         if (is_vlan_dev(edev))
 254                 edev = mlxsw_sp_span_entry_vlan(edev, &vid);
 255
 256         if (netif_is_bridge_master(edev)) {
 257                 edev = mlxsw_sp_span_entry_bridge(edev, dmac, &vid);
 258                 if (!edev)
 259                         goto unoffloadable;
 260         }
 261
 262         if (is_vlan_dev(edev)) {
 263                 if (vid || !(edev->flags & IFF_UP))
 264                         goto unoffloadable;
 265                 edev = mlxsw_sp_span_entry_vlan(edev, &vid);
 266         }
 267
 268         if (netif_is_lag_master(edev)) {
 269                 if (!(edev->flags & IFF_UP))
 270                         goto unoffloadable;
 271                 edev = mlxsw_sp_span_entry_lag(edev);
 272                 if (!edev)
 273                         goto unoffloadable;
 274         }
 275
 276         if (!mlxsw_sp_port_dev_check(edev))
 277                 goto unoffloadable;
 278
 279         sparmsp->dest_port = netdev_priv(edev);
 280         sparmsp->ttl = ttl;
 281         memcpy(sparmsp->dmac, dmac, ETH_ALEN);
 282         memcpy(sparmsp->smac, edev->dev_addr, ETH_ALEN);
 283         sparmsp->saddr = saddr;
 284         sparmsp->daddr = daddr;
 285         sparmsp->vid = vid;
 286         return 0;
 287
 288 unoffloadable:
 289         return mlxsw_sp_span_entry_unoffloadable(sparmsp);
 290 }
 291
 292 #if IS_ENABLED(CONFIG_NET_IPGRE)
 293 static struct net_device *
 294 mlxsw_sp_span_gretap4_route(const struct net_device *to_dev,
 295                             __be32 *saddrp, __be32 *daddrp)
 296 {
 297         struct ip_tunnel *tun = netdev_priv(to_dev);
 298         struct net_device *dev = NULL;
 299         struct ip_tunnel_parm parms;
 300         struct rtable *rt = NULL;
 301         struct flowi4 fl4;
 302
 303         /* We assume "dev" stays valid after rt is put. */
 304         ASSERT_RTNL();
 305
 306         parms = mlxsw_sp_ipip_netdev_parms4(to_dev);
 307         ip_tunnel_init_flow(&fl4, parms.iph.protocol, *daddrp, *saddrp,
 308                             0, 0, parms.link, tun->fwmark, 0);
 309
 310         rt = ip_route_output_key(tun->net, &fl4);
 311         if (IS_ERR(rt))
 312                 return NULL;
 313
 314         if (rt->rt_type != RTN_UNICAST)
 315                 goto out;
 316
 317         dev = rt->dst.dev;
 318         *saddrp = fl4.saddr;
 319         if (rt->rt_gw_family == AF_INET)
 320                 *daddrp = rt->rt_gw4;
 321         /* can not offload if route has an IPv6 gateway */
 322         else if (rt->rt_gw_family == AF_INET6)
 323                 dev = NULL;
 324
 325 out:
 326         ip_rt_put(rt);
 327         return dev;
 328 }
 329
 330 static int
 331 mlxsw_sp_span_entry_gretap4_parms(const struct net_device *to_dev,
 332                                   struct mlxsw_sp_span_parms *sparmsp)
 333 {
 334         struct ip_tunnel_parm tparm = mlxsw_sp_ipip_netdev_parms4(to_dev);
 335         union mlxsw_sp_l3addr saddr = { .addr4 = tparm.iph.saddr };
 336         union mlxsw_sp_l3addr daddr = { .addr4 = tparm.iph.daddr };
 337         bool inherit_tos = tparm.iph.tos & 0x1;
 338         bool inherit_ttl = !tparm.iph.ttl;
 339         union mlxsw_sp_l3addr gw = daddr;
 340         struct net_device *l3edev;
 341
 342         if (!(to_dev->flags & IFF_UP) ||
 343             /* Reject tunnels with GRE keys, checksums, etc. */
 344             tparm.i_flags || tparm.o_flags ||
 345             /* Require a fixed TTL and a TOS copied from the mirrored packet. */
 346             inherit_ttl || !inherit_tos ||
 347             /* A destination address may not be "any". */
 348             mlxsw_sp_l3addr_is_zero(daddr))
 349                 return mlxsw_sp_span_entry_unoffloadable(sparmsp);
 350
 351         l3edev = mlxsw_sp_span_gretap4_route(to_dev, &saddr.addr4, &gw.addr4);
 352         return mlxsw_sp_span_entry_tunnel_parms_common(l3edev, saddr, daddr, gw,
 353                                                        tparm.iph.ttl,
 354                                                        &arp_tbl, sparmsp);
 355 }
 356
 357 static int
 358 mlxsw_sp_span_entry_gretap4_configure(struct mlxsw_sp_span_entry *span_entry,
 359                                       struct mlxsw_sp_span_parms sparms)
 360 {
 361         struct mlxsw_sp_port *dest_port = sparms.dest_port;
 362         struct mlxsw_sp *mlxsw_sp = dest_port->mlxsw_sp;
 363         u8 local_port = dest_port->local_port;
 364         char mpat_pl[MLXSW_REG_MPAT_LEN];
 365         int pa_id = span_entry->id;
 366
 367         /* Create a new port analayzer entry for local_port. */
 368         mlxsw_reg_mpat_pack(mpat_pl, pa_id, local_port, true,
 369                             MLXSW_REG_MPAT_SPAN_TYPE_REMOTE_ETH_L3);
 370         mlxsw_reg_mpat_eth_rspan_pack(mpat_pl, sparms.vid);
 371         mlxsw_reg_mpat_eth_rspan_l2_pack(mpat_pl,
 372                                     MLXSW_REG_MPAT_ETH_RSPAN_VERSION_NO_HEADER,
 373                                     sparms.dmac, !!sparms.vid);
 374         mlxsw_reg_mpat_eth_rspan_l3_ipv4_pack(mpat_pl,
 375                                               sparms.ttl, sparms.smac,
 376                                               be32_to_cpu(sparms.saddr.addr4),
 377                                               be32_to_cpu(sparms.daddr.addr4));
 378
 379         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(mpat), mpat_pl);
 380 }
 381
 382 static void
 383 mlxsw_sp_span_entry_gretap4_deconfigure(struct mlxsw_sp_span_entry *span_entry)
 384 {
 385         mlxsw_sp_span_entry_deconfigure_common(span_entry,
 386                                         MLXSW_REG_MPAT_SPAN_TYPE_REMOTE_ETH_L3);
 387 }
 388
 389 static const struct mlxsw_sp_span_entry_ops mlxsw_sp_span_entry_ops_gretap4 = {
 390         .can_handle = netif_is_gretap,
 391         .parms = mlxsw_sp_span_entry_gretap4_parms,
 392         .configure = mlxsw_sp_span_entry_gretap4_configure,
 393         .deconfigure = mlxsw_sp_span_entry_gretap4_deconfigure,
 394 };
 395 #endif
 396
 397 #if IS_ENABLED(CONFIG_IPV6_GRE)
 398 static struct net_device *
 399 mlxsw_sp_span_gretap6_route(const struct net_device *to_dev,
 400                             struct in6_addr *saddrp,
 401                             struct in6_addr *daddrp)
 402 {
 403         struct ip6_tnl *t = netdev_priv(to_dev);
 404         struct flowi6 fl6 = t->fl.u.ip6;
 405         struct net_device *dev = NULL;
 406         struct dst_entry *dst;
 407         struct rt6_info *rt6;
 408
 409         /* We assume "dev" stays valid after dst is released. */
 410         ASSERT_RTNL();
 411
 412         fl6.flowi6_mark = t->parms.fwmark;
 413         if (!ip6_tnl_xmit_ctl(t, &fl6.saddr, &fl6.daddr))
 414                 return NULL;
 415
 416         dst = ip6_route_output(t->net, NULL, &fl6);
 417         if (!dst || dst->error)
 418                 goto out;
 419
 420         rt6 = container_of(dst, struct rt6_info, dst);
 421
 422         dev = dst->dev;
 423         *saddrp = fl6.saddr;
 424         *daddrp = rt6->rt6i_gateway;
 425
 426 out:
 427         dst_release(dst);
 428         return dev;
 429 }
 430
 431 static int
 432 mlxsw_sp_span_entry_gretap6_parms(const struct net_device *to_dev,
 433                                   struct mlxsw_sp_span_parms *sparmsp)
 434 {
 435         struct __ip6_tnl_parm tparm = mlxsw_sp_ipip_netdev_parms6(to_dev);
 436         bool inherit_tos = tparm.flags & IP6_TNL_F_USE_ORIG_TCLASS;
 437         union mlxsw_sp_l3addr saddr = { .addr6 = tparm.laddr };
 438         union mlxsw_sp_l3addr daddr = { .addr6 = tparm.raddr };
 439         bool inherit_ttl = !tparm.hop_limit;
 440         union mlxsw_sp_l3addr gw = daddr;
 441         struct net_device *l3edev;
 442
 443         if (!(to_dev->flags & IFF_UP) ||
 444             /* Reject tunnels with GRE keys, checksums, etc. */
 445             tparm.i_flags || tparm.o_flags ||
 446             /* Require a fixed TTL and a TOS copied from the mirrored packet. */
 447             inherit_ttl || !inherit_tos ||
 448             /* A destination address may not be "any". */
 449             mlxsw_sp_l3addr_is_zero(daddr))
 450                 return mlxsw_sp_span_entry_unoffloadable(sparmsp);
 451
 452         l3edev = mlxsw_sp_span_gretap6_route(to_dev, &saddr.addr6, &gw.addr6);
 453         return mlxsw_sp_span_entry_tunnel_parms_common(l3edev, saddr, daddr, gw,
 454                                                        tparm.hop_limit,
 455                                                        &nd_tbl, sparmsp);
 456 }
 457
 458 static int
 459 mlxsw_sp_span_entry_gretap6_configure(struct mlxsw_sp_span_entry *span_entry,
 460                                       struct mlxsw_sp_span_parms sparms)
 461 {
 462         struct mlxsw_sp_port *dest_port = sparms.dest_port;
 463         struct mlxsw_sp *mlxsw_sp = dest_port->mlxsw_sp;
 464         u8 local_port = dest_port->local_port;
 465         char mpat_pl[MLXSW_REG_MPAT_LEN];
 466         int pa_id = span_entry->id;
 467
 468         /* Create a new port analayzer entry for local_port. */
 469         mlxsw_reg_mpat_pack(mpat_pl, pa_id, local_port, true,
 470                             MLXSW_REG_MPAT_SPAN_TYPE_REMOTE_ETH_L3);
 471         mlxsw_reg_mpat_eth_rspan_pack(mpat_pl, sparms.vid);
 472         mlxsw_reg_mpat_eth_rspan_l2_pack(mpat_pl,
 473                                     MLXSW_REG_MPAT_ETH_RSPAN_VERSION_NO_HEADER,
 474                                     sparms.dmac, !!sparms.vid);
 475         mlxsw_reg_mpat_eth_rspan_l3_ipv6_pack(mpat_pl, sparms.ttl, sparms.smac,
 476                                               sparms.saddr.addr6,
 477                                               sparms.daddr.addr6);
 478
 479         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(mpat), mpat_pl);
 480 }
 481
 482 static void
 483 mlxsw_sp_span_entry_gretap6_deconfigure(struct mlxsw_sp_span_entry *span_entry)
 484 {
 485         mlxsw_sp_span_entry_deconfigure_common(span_entry,
 486                                         MLXSW_REG_MPAT_SPAN_TYPE_REMOTE_ETH_L3);
 487 }
 488
 489 static const
 490 struct mlxsw_sp_span_entry_ops mlxsw_sp_span_entry_ops_gretap6 = {
 491         .can_handle = netif_is_ip6gretap,
 492         .parms = mlxsw_sp_span_entry_gretap6_parms,
 493         .configure = mlxsw_sp_span_entry_gretap6_configure,
 494         .deconfigure = mlxsw_sp_span_entry_gretap6_deconfigure,
 495 };
 496 #endif
 497
 498 static bool
 499 mlxsw_sp_span_vlan_can_handle(const struct net_device *dev)
 500 {
 501         return is_vlan_dev(dev) &&
 502                mlxsw_sp_port_dev_check(vlan_dev_real_dev(dev));
 503 }
 504
 505 static int
 506 mlxsw_sp_span_entry_vlan_parms(const struct net_device *to_dev,
 507                                struct mlxsw_sp_span_parms *sparmsp)
 508 {
 509         struct net_device *real_dev;
 510         u16 vid;
 511
 512         if (!(to_dev->flags & IFF_UP))
 513                 return mlxsw_sp_span_entry_unoffloadable(sparmsp);
 514
 515         real_dev = mlxsw_sp_span_entry_vlan(to_dev, &vid);
 516         sparmsp->dest_port = netdev_priv(real_dev);
 517         sparmsp->vid = vid;
 518         return 0;
 519 }
 520
 521 static int
 522 mlxsw_sp_span_entry_vlan_configure(struct mlxsw_sp_span_entry *span_entry,
 523                                    struct mlxsw_sp_span_parms sparms)
 524 {
 525         struct mlxsw_sp_port *dest_port = sparms.dest_port;
 526         struct mlxsw_sp *mlxsw_sp = dest_port->mlxsw_sp;
 527         u8 local_port = dest_port->local_port;
 528         char mpat_pl[MLXSW_REG_MPAT_LEN];
 529         int pa_id = span_entry->id;
 530
 531         mlxsw_reg_mpat_pack(mpat_pl, pa_id, local_port, true,
 532                             MLXSW_REG_MPAT_SPAN_TYPE_REMOTE_ETH);
 533         mlxsw_reg_mpat_eth_rspan_pack(mpat_pl, sparms.vid);
 534
 535         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(mpat), mpat_pl);
 536 }
 537
 538 static void
 539 mlxsw_sp_span_entry_vlan_deconfigure(struct mlxsw_sp_span_entry *span_entry)
 540 {
 541         mlxsw_sp_span_entry_deconfigure_common(span_entry,
 542                                         MLXSW_REG_MPAT_SPAN_TYPE_REMOTE_ETH);
 543 }
 544
 545 static const
 546 struct mlxsw_sp_span_entry_ops mlxsw_sp_span_entry_ops_vlan = {
 547         .can_handle = mlxsw_sp_span_vlan_can_handle,
 548         .parms = mlxsw_sp_span_entry_vlan_parms,
 549         .configure = mlxsw_sp_span_entry_vlan_configure,
 550         .deconfigure = mlxsw_sp_span_entry_vlan_deconfigure,
 551 };
 552
 553 static const
 554 struct mlxsw_sp_span_entry_ops *const mlxsw_sp_span_entry_types[] = {
 555         &mlxsw_sp_span_entry_ops_phys,
 556 #if IS_ENABLED(CONFIG_NET_IPGRE)
 557         &mlxsw_sp_span_entry_ops_gretap4,
 558 #endif
 559 #if IS_ENABLED(CONFIG_IPV6_GRE)
 560         &mlxsw_sp_span_entry_ops_gretap6,
 561 #endif
 562         &mlxsw_sp_span_entry_ops_vlan,
 563 };
 564
 565 static int
 566 mlxsw_sp_span_entry_nop_parms(const struct net_device *to_dev,
 567                               struct mlxsw_sp_span_parms *sparmsp)
 568 {
 569         return mlxsw_sp_span_entry_unoffloadable(sparmsp);
 570 }
 571
 572 static int
 573 mlxsw_sp_span_entry_nop_configure(struct mlxsw_sp_span_entry *span_entry,
 574                                   struct mlxsw_sp_span_parms sparms)
 575 {
 576         return 0;
 577 }
 578
 579 static void
 580 mlxsw_sp_span_entry_nop_deconfigure(struct mlxsw_sp_span_entry *span_entry)
 581 {
 582 }
 583
 584 static const struct mlxsw_sp_span_entry_ops mlxsw_sp_span_entry_ops_nop = {
 585         .parms = mlxsw_sp_span_entry_nop_parms,
 586         .configure = mlxsw_sp_span_entry_nop_configure,
 587         .deconfigure = mlxsw_sp_span_entry_nop_deconfigure,
 588 };
 589
 590 static void
 591 mlxsw_sp_span_entry_configure(struct mlxsw_sp *mlxsw_sp,
 592                               struct mlxsw_sp_span_entry *span_entry,
 593                               struct mlxsw_sp_span_parms sparms)
 594 {
 595         if (sparms.dest_port) {
 596                 if (sparms.dest_port->mlxsw_sp != mlxsw_sp) {
 597                         netdev_err(span_entry->to_dev, "Cannot mirror to %s, which belongs to a different mlxsw instance",
 598                                    sparms.dest_port->dev->name);
 599                         sparms.dest_port = NULL;
 600                 } else if (span_entry->ops->configure(span_entry, sparms)) {
 601                         netdev_err(span_entry->to_dev, "Failed to offload mirror to %s",
 602                                    sparms.dest_port->dev->name);
 603                         sparms.dest_port = NULL;
 604                 }
 605         }
 606
 607         span_entry->parms = sparms;
 608 }
 609
 610 static void
 611 mlxsw_sp_span_entry_deconfigure(struct mlxsw_sp_span_entry *span_entry)
 612 {
 613         if (span_entry->parms.dest_port)
 614                 span_entry->ops->deconfigure(span_entry);
 615 }
 616
 617 static struct mlxsw_sp_span_entry *
 618 mlxsw_sp_span_entry_create(struct mlxsw_sp *mlxsw_sp,
 619                            const struct net_device *to_dev,
 620                            const struct mlxsw_sp_span_entry_ops *ops,
 621                            struct mlxsw_sp_span_parms sparms)
 622 {
 623         struct mlxsw_sp_span_entry *span_entry = NULL;
 624         int i;
 625
 626         /* find a free entry to use */
 627         for (i = 0; i < mlxsw_sp->span.entries_count; i++) {
 628                 if (!mlxsw_sp->span.entries[i].ref_count) {
 629                         span_entry = &mlxsw_sp->span.entries[i];
 630                         break;
 631                 }
 632         }
 633         if (!span_entry)
 634                 return NULL;
 635
 636         span_entry->ops = ops;
 637         span_entry->ref_count = 1;
 638         span_entry->to_dev = to_dev;
 639         mlxsw_sp_span_entry_configure(mlxsw_sp, span_entry, sparms);
 640
 641         return span_entry;
 642 }
 643
 644 static void mlxsw_sp_span_entry_destroy(struct mlxsw_sp_span_entry *span_entry)
 645 {
 646         mlxsw_sp_span_entry_deconfigure(span_entry);
 647 }
 648
 649 struct mlxsw_sp_span_entry *
 650 mlxsw_sp_span_entry_find_by_port(struct mlxsw_sp *mlxsw_sp,
 651                                  const struct net_device *to_dev)
 652 {
 653         int i;
 654
 655         for (i = 0; i < mlxsw_sp->span.entries_count; i++) {
 656                 struct mlxsw_sp_span_entry *curr = &mlxsw_sp->span.entries[i];
 657
 658                 if (curr->ref_count && curr->to_dev == to_dev)
 659                         return curr;
 660         }
 661         return NULL;
 662 }
 663
 664 void mlxsw_sp_span_entry_invalidate(struct mlxsw_sp *mlxsw_sp,
 665                                     struct mlxsw_sp_span_entry *span_entry)
 666 {
 667         mlxsw_sp_span_entry_deconfigure(span_entry);
 668         span_entry->ops = &mlxsw_sp_span_entry_ops_nop;
 669 }
 670
 671 static struct mlxsw_sp_span_entry *
 672 mlxsw_sp_span_entry_find_by_id(struct mlxsw_sp *mlxsw_sp, int span_id)
 673 {
 674         int i;
 675
 676         for (i = 0; i < mlxsw_sp->span.entries_count; i++) {
 677                 struct mlxsw_sp_span_entry *curr = &mlxsw_sp->span.entries[i];
 678
 679                 if (curr->ref_count && curr->id == span_id)
 680                         return curr;
 681         }
 682         return NULL;
 683 }
 684
 685 static struct mlxsw_sp_span_entry *
 686 mlxsw_sp_span_entry_get(struct mlxsw_sp *mlxsw_sp,
 687                         const struct net_device *to_dev,
 688                         const struct mlxsw_sp_span_entry_ops *ops,
 689                         struct mlxsw_sp_span_parms sparms)
 690 {
 691         struct mlxsw_sp_span_entry *span_entry;
 692
 693         span_entry = mlxsw_sp_span_entry_find_by_port(mlxsw_sp, to_dev);
 694         if (span_entry) {
 695                 /* Already exists, just take a reference */
 696                 span_entry->ref_count++;
 697                 return span_entry;
 698         }
 699
 700         return mlxsw_sp_span_entry_create(mlxsw_sp, to_dev, ops, sparms);
 701 }
 702
 703 static int mlxsw_sp_span_entry_put(struct mlxsw_sp *mlxsw_sp,
 704                                    struct mlxsw_sp_span_entry *span_entry)
 705 {
 706         WARN_ON(!span_entry->ref_count);
 707         if (--span_entry->ref_count == 0)
 708                 mlxsw_sp_span_entry_destroy(span_entry);
 709         return 0;
 710 }
 711
 712 static bool mlxsw_sp_span_is_egress_mirror(struct mlxsw_sp_port *port)
 713 {
 714         struct mlxsw_sp *mlxsw_sp = port->mlxsw_sp;
 715         struct mlxsw_sp_span_inspected_port *p;
 716         int i;
 717
 718         for (i = 0; i < mlxsw_sp->span.entries_count; i++) {
 719                 struct mlxsw_sp_span_entry *curr = &mlxsw_sp->span.entries[i];
 720
 721                 list_for_each_entry(p, &curr->bound_ports_list, list)
 722                         if (p->local_port == port->local_port &&
 723                             p->type == MLXSW_SP_SPAN_EGRESS)
 724                                 return true;
 725         }
 726
 727         return false;
 728 }
 729
 730 static int mlxsw_sp_span_mtu_to_buffsize(const struct mlxsw_sp *mlxsw_sp,
 731                                          int mtu)
 732 {
 733         return mlxsw_sp_bytes_cells(mlxsw_sp, mtu * 5 / 2) + 1;
 734 }
 735
 736 int mlxsw_sp_span_port_mtu_update(struct mlxsw_sp_port *port, u16 mtu)
 737 {
 738         struct mlxsw_sp *mlxsw_sp = port->mlxsw_sp;
 739         char sbib_pl[MLXSW_REG_SBIB_LEN];
 740         int err;
 741
 742         /* If port is egress mirrored, the shared buffer size should be
 743          * updated according to the mtu value
 744          */
 745         if (mlxsw_sp_span_is_egress_mirror(port)) {
 746                 u32 buffsize = mlxsw_sp_span_mtu_to_buffsize(mlxsw_sp, mtu);
 747
 748                 mlxsw_reg_sbib_pack(sbib_pl, port->local_port, buffsize);
 749                 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sbib), sbib_pl);
 750                 if (err) {
 751                         netdev_err(port->dev, "Could not update shared buffer for mirroring\n");
 752                         return err;
 753                 }
 754         }
 755
 756         return 0;
 757 }
 758
 759 static struct mlxsw_sp_span_inspected_port *
 760 mlxsw_sp_span_entry_bound_port_find(struct mlxsw_sp_span_entry *span_entry,
 761                                     enum mlxsw_sp_span_type type,
 762                                     struct mlxsw_sp_port *port,
 763                                     bool bind)
 764 {
 765         struct mlxsw_sp_span_inspected_port *p;
 766
 767         list_for_each_entry(p, &span_entry->bound_ports_list, list)
 768                 if (type == p->type &&
 769                     port->local_port == p->local_port &&
 770                     bind == p->bound)
 771                         return p;
 772         return NULL;
 773 }
 774
 775 static int
 776 mlxsw_sp_span_inspected_port_bind(struct mlxsw_sp_port *port,
 777                                   struct mlxsw_sp_span_entry *span_entry,
 778                                   enum mlxsw_sp_span_type type,
 779                                   bool bind)
 780 {
 781         struct mlxsw_sp *mlxsw_sp = port->mlxsw_sp;
 782         char mpar_pl[MLXSW_REG_MPAR_LEN];
 783         int pa_id = span_entry->id;
 784
 785         /* bind the port to the SPAN entry */
 786         mlxsw_reg_mpar_pack(mpar_pl, port->local_port,
 787                             (enum mlxsw_reg_mpar_i_e)type, bind, pa_id);
 788         return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(mpar), mpar_pl);
 789 }
 790
 791 static int
 792 mlxsw_sp_span_inspected_port_add(struct mlxsw_sp_port *port,
 793                                  struct mlxsw_sp_span_entry *span_entry,
 794                                  enum mlxsw_sp_span_type type,
 795                                  bool bind)
 796 {
 797         struct mlxsw_sp_span_inspected_port *inspected_port;
 798         struct mlxsw_sp *mlxsw_sp = port->mlxsw_sp;
 799         char sbib_pl[MLXSW_REG_SBIB_LEN];
 800         int i;
 801         int err;
 802
 803         /* A given (source port, direction) can only be bound to one analyzer,
 804          * so if a binding is requested, check for conflicts.
 805          */
 806         if (bind)
 807                 for (i = 0; i < mlxsw_sp->span.entries_count; i++) {
 808                         struct mlxsw_sp_span_entry *curr =
 809                                 &mlxsw_sp->span.entries[i];
 810
 811                         if (mlxsw_sp_span_entry_bound_port_find(curr, type,
 812                                                                 port, bind))
 813                                 return -EEXIST;
 814                 }
 815
 816         /* if it is an egress SPAN, bind a shared buffer to it */
 817         if (type == MLXSW_SP_SPAN_EGRESS) {
 818                 u32 buffsize = mlxsw_sp_span_mtu_to_buffsize(mlxsw_sp,
 819                                                              port->dev->mtu);
 820
 821                 mlxsw_reg_sbib_pack(sbib_pl, port->local_port, buffsize);
 822                 err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sbib), sbib_pl);
 823                 if (err) {
 824                         netdev_err(port->dev, "Could not create shared buffer for mirroring\n");
 825                         return err;
 826                 }
 827         }
 828
 829         if (bind) {
 830                 err = mlxsw_sp_span_inspected_port_bind(port, span_entry, type,
 831                                                         true);
 832                 if (err)
 833                         goto err_port_bind;
 834         }
 835
 836         inspected_port = kzalloc(sizeof(*inspected_port), GFP_KERNEL);
 837         if (!inspected_port) {
 838                 err = -ENOMEM;
 839                 goto err_inspected_port_alloc;
 840         }
 841         inspected_port->local_port = port->local_port;
 842         inspected_port->type = type;
 843         inspected_port->bound = bind;
 844         list_add_tail(&inspected_port->list, &span_entry->bound_ports_list);
 845
 846         return 0;
 847
 848 err_inspected_port_alloc:
 849         if (bind)
 850                 mlxsw_sp_span_inspected_port_bind(port, span_entry, type,
 851                                                   false);
 852 err_port_bind:
 853         if (type == MLXSW_SP_SPAN_EGRESS) {
 854                 mlxsw_reg_sbib_pack(sbib_pl, port->local_port, 0);
 855                 mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sbib), sbib_pl);
 856         }
 857         return err;
 858 }
 859
 860 static void
 861 mlxsw_sp_span_inspected_port_del(struct mlxsw_sp_port *port,
 862                                  struct mlxsw_sp_span_entry *span_entry,
 863                                  enum mlxsw_sp_span_type type,
 864                                  bool bind)
 865 {
 866         struct mlxsw_sp_span_inspected_port *inspected_port;
 867         struct mlxsw_sp *mlxsw_sp = port->mlxsw_sp;
 868         char sbib_pl[MLXSW_REG_SBIB_LEN];
 869
 870         inspected_port = mlxsw_sp_span_entry_bound_port_find(span_entry, type,
 871                                                              port, bind);
 872         if (!inspected_port)
 873                 return;
 874
 875         if (bind)
 876                 mlxsw_sp_span_inspected_port_bind(port, span_entry, type,
 877                                                   false);
 878         /* remove the SBIB buffer if it was egress SPAN */
 879         if (type == MLXSW_SP_SPAN_EGRESS) {
 880                 mlxsw_reg_sbib_pack(sbib_pl, port->local_port, 0);
 881                 mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sbib), sbib_pl);
 882         }
 883
 884         mlxsw_sp_span_entry_put(mlxsw_sp, span_entry);
 885
 886         list_del(&inspected_port->list);
 887         kfree(inspected_port);
 888 }
 889
 890 static const struct mlxsw_sp_span_entry_ops *
 891 mlxsw_sp_span_entry_ops(struct mlxsw_sp *mlxsw_sp,
 892                         const struct net_device *to_dev)
 893 {
 894         size_t i;
 895
 896         for (i = 0; i < ARRAY_SIZE(mlxsw_sp_span_entry_types); ++i)
 897                 if (mlxsw_sp_span_entry_types[i]->can_handle(to_dev))
 898                         return mlxsw_sp_span_entry_types[i];
 899
 900         return NULL;
 901 }
 902
 903 int mlxsw_sp_span_mirror_add(struct mlxsw_sp_port *from,
 904                              const struct net_device *to_dev,
 905                              enum mlxsw_sp_span_type type, bool bind,
 906                              int *p_span_id)
 907 {
 908         struct mlxsw_sp *mlxsw_sp = from->mlxsw_sp;
 909         const struct mlxsw_sp_span_entry_ops *ops;
 910         struct mlxsw_sp_span_parms sparms = {NULL};
 911         struct mlxsw_sp_span_entry *span_entry;
 912         int err;
 913
 914         ops = mlxsw_sp_span_entry_ops(mlxsw_sp, to_dev);
 915         if (!ops) {
 916                 netdev_err(to_dev, "Cannot mirror to %s", to_dev->name);
 917                 return -EOPNOTSUPP;
 918         }
 919
 920         err = ops->parms(to_dev, &sparms);
 921         if (err)
 922                 return err;
 923
 924         span_entry = mlxsw_sp_span_entry_get(mlxsw_sp, to_dev, ops, sparms);
 925         if (!span_entry)
 926                 return -ENOBUFS;
 927
 928         netdev_dbg(from->dev, "Adding inspected port to SPAN entry %d\n",
 929                    span_entry->id);
 930
 931         err = mlxsw_sp_span_inspected_port_add(from, span_entry, type, bind);
 932         if (err)
 933                 goto err_port_bind;
 934
 935         *p_span_id = span_entry->id;
 936         return 0;
 937
 938 err_port_bind:
 939         mlxsw_sp_span_entry_put(mlxsw_sp, span_entry);
 940         return err;
 941 }
 942
 943 void mlxsw_sp_span_mirror_del(struct mlxsw_sp_port *from, int span_id,
 944                               enum mlxsw_sp_span_type type, bool bind)
 945 {
 946         struct mlxsw_sp_span_entry *span_entry;
 947
 948         span_entry = mlxsw_sp_span_entry_find_by_id(from->mlxsw_sp, span_id);
 949         if (!span_entry) {
 950                 netdev_err(from->dev, "no span entry found\n");
 951                 return;
 952         }
 953
 954         netdev_dbg(from->dev, "removing inspected port from SPAN entry %d\n",
 955                    span_entry->id);
 956         mlxsw_sp_span_inspected_port_del(from, span_entry, type, bind);
 957 }
 958
 959 void mlxsw_sp_span_respin(struct mlxsw_sp *mlxsw_sp)
 960 {
 961         int i;
 962         int err;
 963
 964         ASSERT_RTNL();
 965         for (i = 0; i < mlxsw_sp->span.entries_count; i++) {
 966                 struct mlxsw_sp_span_entry *curr = &mlxsw_sp->span.entries[i];
 967                 struct mlxsw_sp_span_parms sparms = {NULL};
 968
 969                 if (!curr->ref_count)
 970                         continue;
 971
 972                 err = curr->ops->parms(curr->to_dev, &sparms);
 973                 if (err)
 974                         continue;
 975
 976                 if (memcmp(&sparms, &curr->parms, sizeof(sparms))) {
 977                         mlxsw_sp_span_entry_deconfigure(curr);
 978                         mlxsw_sp_span_entry_configure(mlxsw_sp, curr, sparms);
 979                 }
 980         }
 981 }