net/bridge/br_mrp.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2
   3 #include <linux/mrp_bridge.h>
   4 #include "br_private_mrp.h"
   5
   6 static const u8 mrp_test_dmac[ETH_ALEN] = { 0x1, 0x15, 0x4e, 0x0, 0x0, 0x1 };
   7 static const u8 mrp_in_test_dmac[ETH_ALEN] = { 0x1, 0x15, 0x4e, 0x0, 0x0, 0x3 };
   8
   9 static int br_mrp_process(struct net_bridge_port *p, struct sk_buff *skb);
  10
  11 static struct br_frame_type mrp_frame_type __read_mostly = {
  12         .type = cpu_to_be16(ETH_P_MRP),
  13         .frame_handler = br_mrp_process,
  14 };
  15
  16 static bool br_mrp_is_ring_port(struct net_bridge_port *p_port,
  17                                 struct net_bridge_port *s_port,
  18                                 struct net_bridge_port *port)
  19 {
  20         if (port == p_port ||
  21             port == s_port)
  22                 return true;
  23
  24         return false;
  25 }
  26
  27 static bool br_mrp_is_in_port(struct net_bridge_port *i_port,
  28                               struct net_bridge_port *port)
  29 {
  30         if (port == i_port)
  31                 return true;
  32
  33         return false;
  34 }
  35
  36 static struct net_bridge_port *br_mrp_get_port(struct net_bridge *br,
  37                                                u32 ifindex)
  38 {
  39         struct net_bridge_port *res = NULL;
  40         struct net_bridge_port *port;
  41
  42         list_for_each_entry(port, &br->port_list, list) {
  43                 if (port->dev->ifindex == ifindex) {
  44                         res = port;
  45                         break;
  46                 }
  47         }
  48
  49         return res;
  50 }
  51
  52 static struct br_mrp *br_mrp_find_id(struct net_bridge *br, u32 ring_id)
  53 {
  54         struct br_mrp *res = NULL;
  55         struct br_mrp *mrp;
  56
  57         hlist_for_each_entry_rcu(mrp, &br->mrp_list, list,
  58                                  lockdep_rtnl_is_held()) {
  59                 if (mrp->ring_id == ring_id) {
  60                         res = mrp;
  61                         break;
  62                 }
  63         }
  64
  65         return res;
  66 }
  67
  68 static struct br_mrp *br_mrp_find_in_id(struct net_bridge *br, u32 in_id)
  69 {
  70         struct br_mrp *res = NULL;
  71         struct br_mrp *mrp;
  72
  73         hlist_for_each_entry_rcu(mrp, &br->mrp_list, list,
  74                                  lockdep_rtnl_is_held()) {
  75                 if (mrp->in_id == in_id) {
  76                         res = mrp;
  77                         break;
  78                 }
  79         }
  80
  81         return res;
  82 }
  83
  84 static bool br_mrp_unique_ifindex(struct net_bridge *br, u32 ifindex)
  85 {
  86         struct br_mrp *mrp;
  87
  88         hlist_for_each_entry_rcu(mrp, &br->mrp_list, list,
  89                                  lockdep_rtnl_is_held()) {
  90                 struct net_bridge_port *p;
  91
  92                 p = rtnl_dereference(mrp->p_port);
  93                 if (p && p->dev->ifindex == ifindex)
  94                         return false;
  95
  96                 p = rtnl_dereference(mrp->s_port);
  97                 if (p && p->dev->ifindex == ifindex)
  98                         return false;
  99
 100                 p = rtnl_dereference(mrp->i_port);
 101                 if (p && p->dev->ifindex == ifindex)
 102                         return false;
 103         }
 104
 105         return true;
 106 }
 107
 108 static struct br_mrp *br_mrp_find_port(struct net_bridge *br,
 109                                        struct net_bridge_port *p)
 110 {
 111         struct br_mrp *res = NULL;
 112         struct br_mrp *mrp;
 113
 114         hlist_for_each_entry_rcu(mrp, &br->mrp_list, list,
 115                                  lockdep_rtnl_is_held()) {
 116                 if (rcu_access_pointer(mrp->p_port) == p ||
 117                     rcu_access_pointer(mrp->s_port) == p ||
 118                     rcu_access_pointer(mrp->i_port) == p) {
 119                         res = mrp;
 120                         break;
 121                 }
 122         }
 123
 124         return res;
 125 }
 126
 127 static int br_mrp_next_seq(struct br_mrp *mrp)
 128 {
 129         mrp->seq_id++;
 130         return mrp->seq_id;
 131 }
 132
 133 static struct sk_buff *br_mrp_skb_alloc(struct net_bridge_port *p,
 134                                         const u8 *src, const u8 *dst)
 135 {
 136         struct ethhdr *eth_hdr;
 137         struct sk_buff *skb;
 138         __be16 *version;
 139
 140         skb = dev_alloc_skb(MRP_MAX_FRAME_LENGTH);
 141         if (!skb)
 142                 return NULL;
 143
 144         skb->dev = p->dev;
 145         skb->protocol = htons(ETH_P_MRP);
 146         skb->priority = MRP_FRAME_PRIO;
 147         skb_reserve(skb, sizeof(*eth_hdr));
 148
 149         eth_hdr = skb_push(skb, sizeof(*eth_hdr));
 150         ether_addr_copy(eth_hdr->h_dest, dst);
 151         ether_addr_copy(eth_hdr->h_source, src);
 152         eth_hdr->h_proto = htons(ETH_P_MRP);
 153
 154         version = skb_put(skb, sizeof(*version));
 155         *version = cpu_to_be16(MRP_VERSION);
 156
 157         return skb;
 158 }
 159
 160 static void br_mrp_skb_tlv(struct sk_buff *skb,
 161                            enum br_mrp_tlv_header_type type,
 162                            u8 length)
 163 {
 164         struct br_mrp_tlv_hdr *hdr;
 165
 166         hdr = skb_put(skb, sizeof(*hdr));
 167         hdr->type = type;
 168         hdr->length = length;
 169 }
 170
 171 static void br_mrp_skb_common(struct sk_buff *skb, struct br_mrp *mrp)
 172 {
 173         struct br_mrp_common_hdr *hdr;
 174
 175         br_mrp_skb_tlv(skb, BR_MRP_TLV_HEADER_COMMON, sizeof(*hdr));
 176
 177         hdr = skb_put(skb, sizeof(*hdr));
 178         hdr->seq_id = cpu_to_be16(br_mrp_next_seq(mrp));
 179         memset(hdr->domain, 0xff, MRP_DOMAIN_UUID_LENGTH);
 180 }
 181
 182 static struct sk_buff *br_mrp_alloc_test_skb(struct br_mrp *mrp,
 183                                              struct net_bridge_port *p,
 184                                              enum br_mrp_port_role_type port_role)
 185 {
 186         struct br_mrp_ring_test_hdr *hdr = NULL;
 187         struct sk_buff *skb = NULL;
 188
 189         if (!p)
 190                 return NULL;
 191
 192         skb = br_mrp_skb_alloc(p, p->dev->dev_addr, mrp_test_dmac);
 193         if (!skb)
 194                 return NULL;
 195
 196         br_mrp_skb_tlv(skb, BR_MRP_TLV_HEADER_RING_TEST, sizeof(*hdr));
 197         hdr = skb_put(skb, sizeof(*hdr));
 198
 199         hdr->prio = cpu_to_be16(mrp->prio);
 200         ether_addr_copy(hdr->sa, p->br->dev->dev_addr);
 201         hdr->port_role = cpu_to_be16(port_role);
 202         hdr->state = cpu_to_be16(mrp->ring_state);
 203         hdr->transitions = cpu_to_be16(mrp->ring_transitions);
 204         hdr->timestamp = cpu_to_be32(jiffies_to_msecs(jiffies));
 205
 206         br_mrp_skb_common(skb, mrp);
 207         br_mrp_skb_tlv(skb, BR_MRP_TLV_HEADER_END, 0x0);
 208
 209         return skb;
 210 }
 211
 212 static struct sk_buff *br_mrp_alloc_in_test_skb(struct br_mrp *mrp,
 213                                                 struct net_bridge_port *p,
 214                                                 enum br_mrp_port_role_type port_role)
 215 {
 216         struct br_mrp_in_test_hdr *hdr = NULL;
 217         struct sk_buff *skb = NULL;
 218
 219         if (!p)
 220                 return NULL;
 221
 222         skb = br_mrp_skb_alloc(p, p->dev->dev_addr, mrp_in_test_dmac);
 223         if (!skb)
 224                 return NULL;
 225
 226         br_mrp_skb_tlv(skb, BR_MRP_TLV_HEADER_IN_TEST, sizeof(*hdr));
 227         hdr = skb_put(skb, sizeof(*hdr));
 228
 229         hdr->id = cpu_to_be16(mrp->in_id);
 230         ether_addr_copy(hdr->sa, p->br->dev->dev_addr);
 231         hdr->port_role = cpu_to_be16(port_role);
 232         hdr->state = cpu_to_be16(mrp->in_state);
 233         hdr->transitions = cpu_to_be16(mrp->in_transitions);
 234         hdr->timestamp = cpu_to_be32(jiffies_to_msecs(jiffies));
 235
 236         br_mrp_skb_common(skb, mrp);
 237         br_mrp_skb_tlv(skb, BR_MRP_TLV_HEADER_END, 0x0);
 238
 239         return skb;
 240 }
 241
 242 /* This function is continuously called in the following cases:
 243  * - when node role is MRM, in this case test_monitor is always set to false
 244  *   because it needs to notify the userspace that the ring is open and needs to
 245  *   send MRP_Test frames
 246  * - when node role is MRA, there are 2 subcases:
 247  *     - when MRA behaves as MRM, in this case is similar with MRM role
 248  *     - when MRA behaves as MRC, in this case test_monitor is set to true,
 249  *       because it needs to detect when it stops seeing MRP_Test frames
 250  *       from MRM node but it doesn't need to send MRP_Test frames.
 251  */
 252 static void br_mrp_test_work_expired(struct work_struct *work)
 253 {
 254         struct delayed_work *del_work = to_delayed_work(work);
 255         struct br_mrp *mrp = container_of(del_work, struct br_mrp, test_work);
 256         struct net_bridge_port *p;
 257         bool notify_open = false;
 258         struct sk_buff *skb;
 259
 260         if (time_before_eq(mrp->test_end, jiffies))
 261                 return;
 262
 263         if (mrp->test_count_miss < mrp->test_max_miss) {
 264                 mrp->test_count_miss++;
 265         } else {
 266                 /* Notify that the ring is open only if the ring state is
 267                  * closed, otherwise it would continue to notify at every
 268                  * interval.
 269                  * Also notify that the ring is open when the node has the
 270                  * role MRA and behaves as MRC. The reason is that the
 271                  * userspace needs to know when the MRM stopped sending
 272                  * MRP_Test frames so that the current node to try to take
 273                  * the role of a MRM.
 274                  */
 275                 if (mrp->ring_state == BR_MRP_RING_STATE_CLOSED ||
 276                     mrp->test_monitor)
 277                         notify_open = true;
 278         }
 279
 280         rcu_read_lock();
 281
 282         p = rcu_dereference(mrp->p_port);
 283         if (p) {
 284                 if (!mrp->test_monitor) {
 285                         skb = br_mrp_alloc_test_skb(mrp, p,
 286                                                     BR_MRP_PORT_ROLE_PRIMARY);
 287                         if (!skb)
 288                                 goto out;
 289
 290                         skb_reset_network_header(skb);
 291                         dev_queue_xmit(skb);
 292                 }
 293
 294                 if (notify_open && !mrp->ring_role_offloaded)
 295                         br_mrp_ring_port_open(p->dev, true);
 296         }
 297
 298         p = rcu_dereference(mrp->s_port);
 299         if (p) {
 300                 if (!mrp->test_monitor) {
 301                         skb = br_mrp_alloc_test_skb(mrp, p,
 302                                                     BR_MRP_PORT_ROLE_SECONDARY);
 303                         if (!skb)
 304                                 goto out;
 305
 306                         skb_reset_network_header(skb);
 307                         dev_queue_xmit(skb);
 308                 }
 309
 310                 if (notify_open && !mrp->ring_role_offloaded)
 311                         br_mrp_ring_port_open(p->dev, true);
 312         }
 313
 314 out:
 315         rcu_read_unlock();
 316
 317         queue_delayed_work(system_wq, &mrp->test_work,
 318                            usecs_to_jiffies(mrp->test_interval));
 319 }
 320
 321 /* This function is continuously called when the node has the interconnect role
 322  * MIM. It would generate interconnect test frames and will send them on all 3
 323  * ports. But will also check if it stop receiving interconnect test frames.
 324  */
 325 static void br_mrp_in_test_work_expired(struct work_struct *work)
 326 {
 327         struct delayed_work *del_work = to_delayed_work(work);
 328         struct br_mrp *mrp = container_of(del_work, struct br_mrp, in_test_work);
 329         struct net_bridge_port *p;
 330         bool notify_open = false;
 331         struct sk_buff *skb;
 332
 333         if (time_before_eq(mrp->in_test_end, jiffies))
 334                 return;
 335
 336         if (mrp->in_test_count_miss < mrp->in_test_max_miss) {
 337                 mrp->in_test_count_miss++;
 338         } else {
 339                 /* Notify that the interconnect ring is open only if the
 340                  * interconnect ring state is closed, otherwise it would
 341                  * continue to notify at every interval.
 342                  */
 343                 if (mrp->in_state == BR_MRP_IN_STATE_CLOSED)
 344                         notify_open = true;
 345         }
 346
 347         rcu_read_lock();
 348
 349         p = rcu_dereference(mrp->p_port);
 350         if (p) {
 351                 skb = br_mrp_alloc_in_test_skb(mrp, p,
 352                                                BR_MRP_PORT_ROLE_PRIMARY);
 353                 if (!skb)
 354                         goto out;
 355
 356                 skb_reset_network_header(skb);
 357                 dev_queue_xmit(skb);
 358
 359                 if (notify_open && !mrp->in_role_offloaded)
 360                         br_mrp_in_port_open(p->dev, true);
 361         }
 362
 363         p = rcu_dereference(mrp->s_port);
 364         if (p) {
 365                 skb = br_mrp_alloc_in_test_skb(mrp, p,
 366                                                BR_MRP_PORT_ROLE_SECONDARY);
 367                 if (!skb)
 368                         goto out;
 369
 370                 skb_reset_network_header(skb);
 371                 dev_queue_xmit(skb);
 372
 373                 if (notify_open && !mrp->in_role_offloaded)
 374                         br_mrp_in_port_open(p->dev, true);
 375         }
 376
 377         p = rcu_dereference(mrp->i_port);
 378         if (p) {
 379                 skb = br_mrp_alloc_in_test_skb(mrp, p,
 380                                                BR_MRP_PORT_ROLE_INTER);
 381                 if (!skb)
 382                         goto out;
 383
 384                 skb_reset_network_header(skb);
 385                 dev_queue_xmit(skb);
 386
 387                 if (notify_open && !mrp->in_role_offloaded)
 388                         br_mrp_in_port_open(p->dev, true);
 389         }
 390
 391 out:
 392         rcu_read_unlock();
 393
 394         queue_delayed_work(system_wq, &mrp->in_test_work,
 395                            usecs_to_jiffies(mrp->in_test_interval));
 396 }
 397
 398 /* Deletes the MRP instance.
 399  * note: called under rtnl_lock
 400  */
 401 static void br_mrp_del_impl(struct net_bridge *br, struct br_mrp *mrp)
 402 {
 403         struct net_bridge_port *p;
 404         u8 state;
 405
 406         /* Stop sending MRP_Test frames */
 407         cancel_delayed_work_sync(&mrp->test_work);
 408         br_mrp_switchdev_send_ring_test(br, mrp, 0, 0, 0, 0);
 409
 410         /* Stop sending MRP_InTest frames if has an interconnect role */
 411         cancel_delayed_work_sync(&mrp->in_test_work);
 412         br_mrp_switchdev_send_in_test(br, mrp, 0, 0, 0);
 413
 414         br_mrp_switchdev_del(br, mrp);
 415
 416         /* Reset the ports */
 417         p = rtnl_dereference(mrp->p_port);
 418         if (p) {
 419                 spin_lock_bh(&br->lock);
 420                 state = netif_running(br->dev) ?
 421                                 BR_STATE_FORWARDING : BR_STATE_DISABLED;
 422                 p->state = state;
 423                 p->flags &= ~BR_MRP_AWARE;
 424                 spin_unlock_bh(&br->lock);
 425                 br_mrp_port_switchdev_set_state(p, state);
 426                 rcu_assign_pointer(mrp->p_port, NULL);
 427         }
 428
 429         p = rtnl_dereference(mrp->s_port);
 430         if (p) {
 431                 spin_lock_bh(&br->lock);
 432                 state = netif_running(br->dev) ?
 433                                 BR_STATE_FORWARDING : BR_STATE_DISABLED;
 434                 p->state = state;
 435                 p->flags &= ~BR_MRP_AWARE;
 436                 spin_unlock_bh(&br->lock);
 437                 br_mrp_port_switchdev_set_state(p, state);
 438                 rcu_assign_pointer(mrp->s_port, NULL);
 439         }
 440
 441         p = rtnl_dereference(mrp->i_port);
 442         if (p) {
 443                 spin_lock_bh(&br->lock);
 444                 state = netif_running(br->dev) ?
 445                                 BR_STATE_FORWARDING : BR_STATE_DISABLED;
 446                 p->state = state;
 447                 p->flags &= ~BR_MRP_AWARE;
 448                 spin_unlock_bh(&br->lock);
 449                 br_mrp_port_switchdev_set_state(p, state);
 450                 rcu_assign_pointer(mrp->i_port, NULL);
 451         }
 452
 453         hlist_del_rcu(&mrp->list);
 454         kfree_rcu(mrp, rcu);
 455
 456         if (hlist_empty(&br->mrp_list))
 457                 br_del_frame(br, &mrp_frame_type);
 458 }
 459
 460 /* Adds a new MRP instance.
 461  * note: called under rtnl_lock
 462  */
 463 int br_mrp_add(struct net_bridge *br, struct br_mrp_instance *instance)
 464 {
 465         struct net_bridge_port *p;
 466         struct br_mrp *mrp;
 467         int err;
 468
 469         /* If the ring exists, it is not possible to create another one with the
 470          * same ring_id
 471          */
 472         mrp = br_mrp_find_id(br, instance->ring_id);
 473         if (mrp)
 474                 return -EINVAL;
 475
 476         if (!br_mrp_get_port(br, instance->p_ifindex) ||
 477             !br_mrp_get_port(br, instance->s_ifindex))
 478                 return -EINVAL;
 479
 480         /* It is not possible to have the same port part of multiple rings */
 481         if (!br_mrp_unique_ifindex(br, instance->p_ifindex) ||
 482             !br_mrp_unique_ifindex(br, instance->s_ifindex))
 483                 return -EINVAL;
 484
 485         mrp = kzalloc(sizeof(*mrp), GFP_KERNEL);
 486         if (!mrp)
 487                 return -ENOMEM;
 488
 489         mrp->ring_id = instance->ring_id;
 490         mrp->prio = instance->prio;
 491
 492         p = br_mrp_get_port(br, instance->p_ifindex);
 493         spin_lock_bh(&br->lock);
 494         p->state = BR_STATE_FORWARDING;
 495         p->flags |= BR_MRP_AWARE;
 496         spin_unlock_bh(&br->lock);
 497         rcu_assign_pointer(mrp->p_port, p);
 498
 499         p = br_mrp_get_port(br, instance->s_ifindex);
 500         spin_lock_bh(&br->lock);
 501         p->state = BR_STATE_FORWARDING;
 502         p->flags |= BR_MRP_AWARE;
 503         spin_unlock_bh(&br->lock);
 504         rcu_assign_pointer(mrp->s_port, p);
 505
 506         if (hlist_empty(&br->mrp_list))
 507                 br_add_frame(br, &mrp_frame_type);
 508
 509         INIT_DELAYED_WORK(&mrp->test_work, br_mrp_test_work_expired);
 510         INIT_DELAYED_WORK(&mrp->in_test_work, br_mrp_in_test_work_expired);
 511         hlist_add_tail_rcu(&mrp->list, &br->mrp_list);
 512
 513         err = br_mrp_switchdev_add(br, mrp);
 514         if (err)
 515                 goto delete_mrp;
 516
 517         return 0;
 518
 519 delete_mrp:
 520         br_mrp_del_impl(br, mrp);
 521
 522         return err;
 523 }
 524
 525 /* Deletes the MRP instance from which the port is part of
 526  * note: called under rtnl_lock
 527  */
 528 void br_mrp_port_del(struct net_bridge *br, struct net_bridge_port *p)
 529 {
 530         struct br_mrp *mrp = br_mrp_find_port(br, p);
 531
 532         /* If the port is not part of a MRP instance just bail out */
 533         if (!mrp)
 534                 return;
 535
 536         br_mrp_del_impl(br, mrp);
 537 }
 538
 539 /* Deletes existing MRP instance based on ring_id
 540  * note: called under rtnl_lock
 541  */
 542 int br_mrp_del(struct net_bridge *br, struct br_mrp_instance *instance)
 543 {
 544         struct br_mrp *mrp = br_mrp_find_id(br, instance->ring_id);
 545
 546         if (!mrp)
 547                 return -EINVAL;
 548
 549         br_mrp_del_impl(br, mrp);
 550
 551         return 0;
 552 }
 553
 554 /* Set port state, port state can be forwarding, blocked or disabled
 555  * note: already called with rtnl_lock
 556  */
 557 int br_mrp_set_port_state(struct net_bridge_port *p,
 558                           enum br_mrp_port_state_type state)
 559 {
 560         u32 port_state;
 561
 562         if (!p || !(p->flags & BR_MRP_AWARE))
 563                 return -EINVAL;
 564
 565         spin_lock_bh(&p->br->lock);
 566
 567         if (state == BR_MRP_PORT_STATE_FORWARDING)
 568                 port_state = BR_STATE_FORWARDING;
 569         else
 570                 port_state = BR_STATE_BLOCKING;
 571
 572         p->state = port_state;
 573         spin_unlock_bh(&p->br->lock);
 574
 575         br_mrp_port_switchdev_set_state(p, port_state);
 576
 577         return 0;
 578 }
 579
 580 /* Set port role, port role can be primary or secondary
 581  * note: already called with rtnl_lock
 582  */
 583 int br_mrp_set_port_role(struct net_bridge_port *p,
 584                          enum br_mrp_port_role_type role)
 585 {
 586         struct br_mrp *mrp;
 587
 588         if (!p || !(p->flags & BR_MRP_AWARE))
 589                 return -EINVAL;
 590
 591         mrp = br_mrp_find_port(p->br, p);
 592
 593         if (!mrp)
 594                 return -EINVAL;
 595
 596         switch (role) {
 597         case BR_MRP_PORT_ROLE_PRIMARY:
 598                 rcu_assign_pointer(mrp->p_port, p);
 599                 break;
 600         case BR_MRP_PORT_ROLE_SECONDARY:
 601                 rcu_assign_pointer(mrp->s_port, p);
 602                 break;
 603         default:
 604                 return -EINVAL;
 605         }
 606
 607         br_mrp_port_switchdev_set_role(p, role);
 608
 609         return 0;
 610 }
 611
 612 /* Set ring state, ring state can be only Open or Closed
 613  * note: already called with rtnl_lock
 614  */
 615 int br_mrp_set_ring_state(struct net_bridge *br,
 616                           struct br_mrp_ring_state *state)
 617 {
 618         struct br_mrp *mrp = br_mrp_find_id(br, state->ring_id);
 619
 620         if (!mrp)
 621                 return -EINVAL;
 622
 623         if (mrp->ring_state == BR_MRP_RING_STATE_CLOSED &&
 624             state->ring_state != BR_MRP_RING_STATE_CLOSED)
 625                 mrp->ring_transitions++;
 626
 627         mrp->ring_state = state->ring_state;
 628
 629         br_mrp_switchdev_set_ring_state(br, mrp, state->ring_state);
 630
 631         return 0;
 632 }
 633
 634 /* Set ring role, ring role can be only MRM(Media Redundancy Manager) or
 635  * MRC(Media Redundancy Client).
 636  * note: already called with rtnl_lock
 637  */
 638 int br_mrp_set_ring_role(struct net_bridge *br,
 639                          struct br_mrp_ring_role *role)
 640 {
 641         struct br_mrp *mrp = br_mrp_find_id(br, role->ring_id);
 642         enum br_mrp_hw_support support;
 643
 644         if (!mrp)
 645                 return -EINVAL;
 646
 647         mrp->ring_role = role->ring_role;
 648
 649         /* If there is an error just bailed out */
 650         support = br_mrp_switchdev_set_ring_role(br, mrp, role->ring_role);
 651         if (support == BR_MRP_NONE)
 652                 return -EOPNOTSUPP;
 653
 654         /* Now detect if the HW actually applied the role or not. If the HW
 655          * applied the role it means that the SW will not to do those operations
 656          * anymore. For example if the role ir MRM then the HW will notify the
 657          * SW when ring is open, but if the is not pushed to the HW the SW will
 658          * need to detect when the ring is open
 659          */
 660         mrp->ring_role_offloaded = support == BR_MRP_SW ? 0 : 1;
 661
 662         return 0;
 663 }
 664
 665 /* Start to generate or monitor MRP test frames, the frames are generated by
 666  * HW and if it fails, they are generated by the SW.
 667  * note: already called with rtnl_lock
 668  */
 669 int br_mrp_start_test(struct net_bridge *br,
 670                       struct br_mrp_start_test *test)
 671 {
 672         struct br_mrp *mrp = br_mrp_find_id(br, test->ring_id);
 673         enum br_mrp_hw_support support;
 674
 675         if (!mrp)
 676                 return -EINVAL;
 677
 678         /* Try to push it to the HW and if it fails then continue with SW
 679          * implementation and if that also fails then return error.
 680          */
 681         support = br_mrp_switchdev_send_ring_test(br, mrp, test->interval,
 682                                                   test->max_miss, test->period,
 683                                                   test->monitor);
 684         if (support == BR_MRP_NONE)
 685                 return -EOPNOTSUPP;
 686
 687         if (support == BR_MRP_HW)
 688                 return 0;
 689
 690         mrp->test_interval = test->interval;
 691         mrp->test_end = jiffies + usecs_to_jiffies(test->period);
 692         mrp->test_max_miss = test->max_miss;
 693         mrp->test_monitor = test->monitor;
 694         mrp->test_count_miss = 0;
 695         queue_delayed_work(system_wq, &mrp->test_work,
 696                            usecs_to_jiffies(test->interval));
 697
 698         return 0;
 699 }
 700
 701 /* Set in state, int state can be only Open or Closed
 702  * note: already called with rtnl_lock
 703  */
 704 int br_mrp_set_in_state(struct net_bridge *br, struct br_mrp_in_state *state)
 705 {
 706         struct br_mrp *mrp = br_mrp_find_in_id(br, state->in_id);
 707
 708         if (!mrp)
 709                 return -EINVAL;
 710
 711         if (mrp->in_state == BR_MRP_IN_STATE_CLOSED &&
 712             state->in_state != BR_MRP_IN_STATE_CLOSED)
 713                 mrp->in_transitions++;
 714
 715         mrp->in_state = state->in_state;
 716
 717         br_mrp_switchdev_set_in_state(br, mrp, state->in_state);
 718
 719         return 0;
 720 }
 721
 722 /* Set in role, in role can be only MIM(Media Interconnection Manager) or
 723  * MIC(Media Interconnection Client).
 724  * note: already called with rtnl_lock
 725  */
 726 int br_mrp_set_in_role(struct net_bridge *br, struct br_mrp_in_role *role)
 727 {
 728         struct br_mrp *mrp = br_mrp_find_id(br, role->ring_id);
 729         enum br_mrp_hw_support support;
 730         struct net_bridge_port *p;
 731
 732         if (!mrp)
 733                 return -EINVAL;
 734
 735         if (!br_mrp_get_port(br, role->i_ifindex))
 736                 return -EINVAL;
 737
 738         if (role->in_role == BR_MRP_IN_ROLE_DISABLED) {
 739                 u8 state;
 740
 741                 /* It is not allowed to disable a port that doesn't exist */
 742                 p = rtnl_dereference(mrp->i_port);
 743                 if (!p)
 744                         return -EINVAL;
 745
 746                 /* Stop the generating MRP_InTest frames */
 747                 cancel_delayed_work_sync(&mrp->in_test_work);
 748                 br_mrp_switchdev_send_in_test(br, mrp, 0, 0, 0);
 749
 750                 /* Remove the port */
 751                 spin_lock_bh(&br->lock);
 752                 state = netif_running(br->dev) ?
 753                                 BR_STATE_FORWARDING : BR_STATE_DISABLED;
 754                 p->state = state;
 755                 p->flags &= ~BR_MRP_AWARE;
 756                 spin_unlock_bh(&br->lock);
 757                 br_mrp_port_switchdev_set_state(p, state);
 758                 rcu_assign_pointer(mrp->i_port, NULL);
 759
 760                 mrp->in_role = role->in_role;
 761                 mrp->in_id = 0;
 762
 763                 return 0;
 764         }
 765
 766         /* It is not possible to have the same port part of multiple rings */
 767         if (!br_mrp_unique_ifindex(br, role->i_ifindex))
 768                 return -EINVAL;
 769
 770         /* It is not allowed to set a different interconnect port if the mrp
 771          * instance has already one. First it needs to be disabled and after
 772          * that set the new port
 773          */
 774         if (rcu_access_pointer(mrp->i_port))
 775                 return -EINVAL;
 776
 777         p = br_mrp_get_port(br, role->i_ifindex);
 778         spin_lock_bh(&br->lock);
 779         p->state = BR_STATE_FORWARDING;
 780         p->flags |= BR_MRP_AWARE;
 781         spin_unlock_bh(&br->lock);
 782         rcu_assign_pointer(mrp->i_port, p);
 783
 784         mrp->in_role = role->in_role;
 785         mrp->in_id = role->in_id;
 786
 787         /* If there is an error just bailed out */
 788         support = br_mrp_switchdev_set_in_role(br, mrp, role->in_id,
 789                                                role->ring_id, role->in_role);
 790         if (support == BR_MRP_NONE)
 791                 return -EOPNOTSUPP;
 792
 793         /* Now detect if the HW actually applied the role or not. If the HW
 794          * applied the role it means that the SW will not to do those operations
 795          * anymore. For example if the role is MIM then the HW will notify the
 796          * SW when interconnect ring is open, but if the is not pushed to the HW
 797          * the SW will need to detect when the interconnect ring is open.
 798          */
 799         mrp->in_role_offloaded = support == BR_MRP_SW ? 0 : 1;
 800
 801         return 0;
 802 }
 803
 804 /* Start to generate MRP_InTest frames, the frames are generated by
 805  * HW and if it fails, they are generated by the SW.
 806  * note: already called with rtnl_lock
 807  */
 808 int br_mrp_start_in_test(struct net_bridge *br,
 809                          struct br_mrp_start_in_test *in_test)
 810 {
 811         struct br_mrp *mrp = br_mrp_find_in_id(br, in_test->in_id);
 812         enum br_mrp_hw_support support;
 813
 814         if (!mrp)
 815                 return -EINVAL;
 816
 817         if (mrp->in_role != BR_MRP_IN_ROLE_MIM)
 818                 return -EINVAL;
 819
 820         /* Try to push it to the HW and if it fails then continue with SW
 821          * implementation and if that also fails then return error.
 822          */
 823         support =  br_mrp_switchdev_send_in_test(br, mrp, in_test->interval,
 824                                                  in_test->max_miss,
 825                                                  in_test->period);
 826         if (support == BR_MRP_NONE)
 827                 return -EOPNOTSUPP;
 828
 829         if (support == BR_MRP_HW)
 830                 return 0;
 831
 832         mrp->in_test_interval = in_test->interval;
 833         mrp->in_test_end = jiffies + usecs_to_jiffies(in_test->period);
 834         mrp->in_test_max_miss = in_test->max_miss;
 835         mrp->in_test_count_miss = 0;
 836         queue_delayed_work(system_wq, &mrp->in_test_work,
 837                            usecs_to_jiffies(in_test->interval));
 838
 839         return 0;
 840 }
 841
 842 /* Determine if the frame type is a ring frame */
 843 static bool br_mrp_ring_frame(struct sk_buff *skb)
 844 {
 845         const struct br_mrp_tlv_hdr *hdr;
 846         struct br_mrp_tlv_hdr _hdr;
 847
 848         hdr = skb_header_pointer(skb, sizeof(uint16_t), sizeof(_hdr), &_hdr);
 849         if (!hdr)
 850                 return false;
 851
 852         if (hdr->type == BR_MRP_TLV_HEADER_RING_TEST ||
 853             hdr->type == BR_MRP_TLV_HEADER_RING_TOPO ||
 854             hdr->type == BR_MRP_TLV_HEADER_RING_LINK_DOWN ||
 855             hdr->type == BR_MRP_TLV_HEADER_RING_LINK_UP ||
 856             hdr->type == BR_MRP_TLV_HEADER_OPTION)
 857                 return true;
 858
 859         return false;
 860 }
 861
 862 /* Determine if the frame type is an interconnect frame */
 863 static bool br_mrp_in_frame(struct sk_buff *skb)
 864 {
 865         const struct br_mrp_tlv_hdr *hdr;
 866         struct br_mrp_tlv_hdr _hdr;
 867
 868         hdr = skb_header_pointer(skb, sizeof(uint16_t), sizeof(_hdr), &_hdr);
 869         if (!hdr)
 870                 return false;
 871
 872         if (hdr->type == BR_MRP_TLV_HEADER_IN_TEST ||
 873             hdr->type == BR_MRP_TLV_HEADER_IN_TOPO ||
 874             hdr->type == BR_MRP_TLV_HEADER_IN_LINK_DOWN ||
 875             hdr->type == BR_MRP_TLV_HEADER_IN_LINK_UP ||
 876             hdr->type == BR_MRP_TLV_HEADER_IN_LINK_STATUS)
 877                 return true;
 878
 879         return false;
 880 }
 881
 882 /* Process only MRP Test frame. All the other MRP frames are processed by
 883  * userspace application
 884  * note: already called with rcu_read_lock
 885  */
 886 static void br_mrp_mrm_process(struct br_mrp *mrp, struct net_bridge_port *port,
 887                                struct sk_buff *skb)
 888 {
 889         const struct br_mrp_tlv_hdr *hdr;
 890         struct br_mrp_tlv_hdr _hdr;
 891
 892         /* Each MRP header starts with a version field which is 16 bits.
 893          * Therefore skip the version and get directly the TLV header.
 894          */
 895         hdr = skb_header_pointer(skb, sizeof(uint16_t), sizeof(_hdr), &_hdr);
 896         if (!hdr)
 897                 return;
 898
 899         if (hdr->type != BR_MRP_TLV_HEADER_RING_TEST)
 900                 return;
 901
 902         mrp->test_count_miss = 0;
 903
 904         /* Notify the userspace that the ring is closed only when the ring is
 905          * not closed
 906          */
 907         if (mrp->ring_state != BR_MRP_RING_STATE_CLOSED)
 908                 br_mrp_ring_port_open(port->dev, false);
 909 }
 910
 911 /* Determine if the test hdr has a better priority than the node */
 912 static bool br_mrp_test_better_than_own(struct br_mrp *mrp,
 913                                         struct net_bridge *br,
 914                                         const struct br_mrp_ring_test_hdr *hdr)
 915 {
 916         u16 prio = be16_to_cpu(hdr->prio);
 917
 918         if (prio < mrp->prio ||
 919             (prio == mrp->prio &&
 920             ether_addr_to_u64(hdr->sa) < ether_addr_to_u64(br->dev->dev_addr)))
 921                 return true;
 922
 923         return false;
 924 }
 925
 926 /* Process only MRP Test frame. All the other MRP frames are processed by
 927  * userspace application
 928  * note: already called with rcu_read_lock
 929  */
 930 static void br_mrp_mra_process(struct br_mrp *mrp, struct net_bridge *br,
 931                                struct net_bridge_port *port,
 932                                struct sk_buff *skb)
 933 {
 934         const struct br_mrp_ring_test_hdr *test_hdr;
 935         struct br_mrp_ring_test_hdr _test_hdr;
 936         const struct br_mrp_tlv_hdr *hdr;
 937         struct br_mrp_tlv_hdr _hdr;
 938
 939         /* Each MRP header starts with a version field which is 16 bits.
 940          * Therefore skip the version and get directly the TLV header.
 941          */
 942         hdr = skb_header_pointer(skb, sizeof(uint16_t), sizeof(_hdr), &_hdr);
 943         if (!hdr)
 944                 return;
 945
 946         if (hdr->type != BR_MRP_TLV_HEADER_RING_TEST)
 947                 return;
 948
 949         test_hdr = skb_header_pointer(skb, sizeof(uint16_t) + sizeof(_hdr),
 950                                       sizeof(_test_hdr), &_test_hdr);
 951         if (!test_hdr)
 952                 return;
 953
 954         /* Only frames that have a better priority than the node will
 955          * clear the miss counter because otherwise the node will need to behave
 956          * as MRM.
 957          */
 958         if (br_mrp_test_better_than_own(mrp, br, test_hdr))
 959                 mrp->test_count_miss = 0;
 960 }
 961
 962 /* Process only MRP InTest frame. All the other MRP frames are processed by
 963  * userspace application
 964  * note: already called with rcu_read_lock
 965  */
 966 static bool br_mrp_mim_process(struct br_mrp *mrp, struct net_bridge_port *port,
 967                                struct sk_buff *skb)
 968 {
 969         const struct br_mrp_in_test_hdr *in_hdr;
 970         struct br_mrp_in_test_hdr _in_hdr;
 971         const struct br_mrp_tlv_hdr *hdr;
 972         struct br_mrp_tlv_hdr _hdr;
 973
 974         /* Each MRP header starts with a version field which is 16 bits.
 975          * Therefore skip the version and get directly the TLV header.
 976          */
 977         hdr = skb_header_pointer(skb, sizeof(uint16_t), sizeof(_hdr), &_hdr);
 978         if (!hdr)
 979                 return false;
 980
 981         /* The check for InTest frame type was already done */
 982         in_hdr = skb_header_pointer(skb, sizeof(uint16_t) + sizeof(_hdr),
 983                                     sizeof(_in_hdr), &_in_hdr);
 984         if (!in_hdr)
 985                 return false;
 986
 987         /* It needs to process only it's own InTest frames. */
 988         if (mrp->in_id != ntohs(in_hdr->id))
 989                 return false;
 990
 991         mrp->in_test_count_miss = 0;
 992
 993         /* Notify the userspace that the ring is closed only when the ring is
 994          * not closed
 995          */
 996         if (mrp->in_state != BR_MRP_IN_STATE_CLOSED)
 997                 br_mrp_in_port_open(port->dev, false);
 998
 999         return true;
1000 }
1001
1002 /* Get the MRP frame type
1003  * note: already called with rcu_read_lock
1004  */
1005 static u8 br_mrp_get_frame_type(struct sk_buff *skb)
1006 {
1007         const struct br_mrp_tlv_hdr *hdr;
1008         struct br_mrp_tlv_hdr _hdr;
1009
1010         /* Each MRP header starts with a version field which is 16 bits.
1011          * Therefore skip the version and get directly the TLV header.
1012          */
1013         hdr = skb_header_pointer(skb, sizeof(uint16_t), sizeof(_hdr), &_hdr);
1014         if (!hdr)
1015                 return 0xff;
1016
1017         return hdr->type;
1018 }
1019
1020 static bool br_mrp_mrm_behaviour(struct br_mrp *mrp)
1021 {
1022         if (mrp->ring_role == BR_MRP_RING_ROLE_MRM ||
1023             (mrp->ring_role == BR_MRP_RING_ROLE_MRA && !mrp->test_monitor))
1024                 return true;
1025
1026         return false;
1027 }
1028
1029 static bool br_mrp_mrc_behaviour(struct br_mrp *mrp)
1030 {
1031         if (mrp->ring_role == BR_MRP_RING_ROLE_MRC ||
1032             (mrp->ring_role == BR_MRP_RING_ROLE_MRA && mrp->test_monitor))
1033                 return true;
1034
1035         return false;
1036 }
1037
1038 /* This will just forward the frame to the other mrp ring ports, depending on
1039  * the frame type, ring role and interconnect role
1040  * note: already called with rcu_read_lock
1041  */
1042 static int br_mrp_rcv(struct net_bridge_port *p,
1043                       struct sk_buff *skb, struct net_device *dev)
1044 {
1045         struct net_bridge_port *p_port, *s_port, *i_port = NULL;
1046         struct net_bridge_port *p_dst, *s_dst, *i_dst = NULL;
1047         struct net_bridge *br;
1048         struct br_mrp *mrp;
1049
1050         /* If port is disabled don't accept any frames */
1051         if (p->state == BR_STATE_DISABLED)
1052                 return 0;
1053
1054         br = p->br;
1055         mrp =  br_mrp_find_port(br, p);
1056         if (unlikely(!mrp))
1057                 return 0;
1058
1059         p_port = rcu_dereference(mrp->p_port);
1060         if (!p_port)
1061                 return 0;
1062         p_dst = p_port;
1063
1064         s_port = rcu_dereference(mrp->s_port);
1065         if (!s_port)
1066                 return 0;
1067         s_dst = s_port;
1068
1069         /* If the frame is a ring frame then it is not required to check the
1070          * interconnect role and ports to process or forward the frame
1071          */
1072         if (br_mrp_ring_frame(skb)) {
1073                 /* If the role is MRM then don't forward the frames */
1074                 if (mrp->ring_role == BR_MRP_RING_ROLE_MRM) {
1075                         br_mrp_mrm_process(mrp, p, skb);
1076                         goto no_forward;
1077                 }
1078
1079                 /* If the role is MRA then don't forward the frames if it
1080                  * behaves as MRM node
1081                  */
1082                 if (mrp->ring_role == BR_MRP_RING_ROLE_MRA) {
1083                         if (!mrp->test_monitor) {
1084                                 br_mrp_mrm_process(mrp, p, skb);
1085                                 goto no_forward;
1086                         }
1087
1088                         br_mrp_mra_process(mrp, br, p, skb);
1089                 }
1090
1091                 goto forward;
1092         }
1093
1094         if (br_mrp_in_frame(skb)) {
1095                 u8 in_type = br_mrp_get_frame_type(skb);
1096
1097                 i_port = rcu_dereference(mrp->i_port);
1098                 i_dst = i_port;
1099
1100                 /* If the ring port is in block state it should not forward
1101                  * In_Test frames
1102                  */
1103                 if (br_mrp_is_ring_port(p_port, s_port, p) &&
1104                     p->state == BR_STATE_BLOCKING &&
1105                     in_type == BR_MRP_TLV_HEADER_IN_TEST)
1106                         goto no_forward;
1107
1108                 /* Nodes that behaves as MRM needs to stop forwarding the
1109                  * frames in case the ring is closed, otherwise will be a loop.
1110                  * In this case the frame is no forward between the ring ports.
1111                  */
1112                 if (br_mrp_mrm_behaviour(mrp) &&
1113                     br_mrp_is_ring_port(p_port, s_port, p) &&
1114                     (s_port->state != BR_STATE_FORWARDING ||
1115                      p_port->state != BR_STATE_FORWARDING)) {
1116                         p_dst = NULL;
1117                         s_dst = NULL;
1118                 }
1119
1120                 /* A node that behaves as MRC and doesn't have a interconnect
1121                  * role then it should forward all frames between the ring ports
1122                  * because it doesn't have an interconnect port
1123                  */
1124                 if (br_mrp_mrc_behaviour(mrp) &&
1125                     mrp->in_role == BR_MRP_IN_ROLE_DISABLED)
1126                         goto forward;
1127
1128                 if (mrp->in_role == BR_MRP_IN_ROLE_MIM) {
1129                         if (in_type == BR_MRP_TLV_HEADER_IN_TEST) {
1130                                 /* MIM should not forward it's own InTest
1131                                  * frames
1132                                  */
1133                                 if (br_mrp_mim_process(mrp, p, skb)) {
1134                                         goto no_forward;
1135                                 } else {
1136                                         if (br_mrp_is_ring_port(p_port, s_port,
1137                                                                 p))
1138                                                 i_dst = NULL;
1139
1140                                         if (br_mrp_is_in_port(i_port, p))
1141                                                 goto no_forward;
1142                                 }
1143                         } else {
1144                                 /* MIM should forward IntLinkChange/Status and
1145                                  * IntTopoChange between ring ports but MIM
1146                                  * should not forward IntLinkChange/Status and
1147                                  * IntTopoChange if the frame was received at
1148                                  * the interconnect port
1149                                  */
1150                                 if (br_mrp_is_ring_port(p_port, s_port, p))
1151                                         i_dst = NULL;
1152
1153                                 if (br_mrp_is_in_port(i_port, p))
1154                                         goto no_forward;
1155                         }
1156                 }
1157
1158                 if (mrp->in_role == BR_MRP_IN_ROLE_MIC) {
1159                         /* MIC should forward InTest frames on all ports
1160                          * regardless of the received port
1161                          */
1162                         if (in_type == BR_MRP_TLV_HEADER_IN_TEST)
1163                                 goto forward;
1164
1165                         /* MIC should forward IntLinkChange frames only if they
1166                          * are received on ring ports to all the ports
1167                          */
1168                         if (br_mrp_is_ring_port(p_port, s_port, p) &&
1169                             (in_type == BR_MRP_TLV_HEADER_IN_LINK_UP ||
1170                              in_type == BR_MRP_TLV_HEADER_IN_LINK_DOWN))
1171                                 goto forward;
1172
1173                         /* MIC should forward IntLinkStatus frames only to
1174                          * interconnect port if it was received on a ring port.
1175                          * If it is received on interconnect port then, it
1176                          * should be forward on both ring ports
1177                          */
1178                         if (br_mrp_is_ring_port(p_port, s_port, p) &&
1179                             in_type == BR_MRP_TLV_HEADER_IN_LINK_STATUS) {
1180                                 p_dst = NULL;
1181                                 s_dst = NULL;
1182                         }
1183
1184                         /* Should forward the InTopo frames only between the
1185                          * ring ports
1186                          */
1187                         if (in_type == BR_MRP_TLV_HEADER_IN_TOPO) {
1188                                 i_dst = NULL;
1189                                 goto forward;
1190                         }
1191
1192                         /* In all the other cases don't forward the frames */
1193                         goto no_forward;
1194                 }
1195         }
1196
1197 forward:
1198         if (p_dst)
1199                 br_forward(p_dst, skb, true, false);
1200         if (s_dst)
1201                 br_forward(s_dst, skb, true, false);
1202         if (i_dst)
1203                 br_forward(i_dst, skb, true, false);
1204
1205 no_forward:
1206         return 1;
1207 }
1208
1209 /* Check if the frame was received on a port that is part of MRP ring
1210  * and if the frame has MRP eth. In that case process the frame otherwise do
1211  * normal forwarding.
1212  * note: already called with rcu_read_lock
1213  */
1214 static int br_mrp_process(struct net_bridge_port *p, struct sk_buff *skb)
1215 {
1216         /* If there is no MRP instance do normal forwarding */
1217         if (likely(!(p->flags & BR_MRP_AWARE)))
1218                 goto out;
1219
1220         return br_mrp_rcv(p, skb, p->dev);
1221 out:
1222         return 0;
1223 }
1224
1225 bool br_mrp_enabled(struct net_bridge *br)
1226 {
1227         return !hlist_empty(&br->mrp_list);
1228 }