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         /* Disable the roles */
 415         br_mrp_switchdev_set_ring_role(br, mrp, BR_MRP_RING_ROLE_DISABLED);
 416         p = rtnl_dereference(mrp->i_port);
 417         if (p)
 418                 br_mrp_switchdev_set_in_role(br, mrp, mrp->in_id, mrp->ring_id,
 419                                              BR_MRP_IN_ROLE_DISABLED);
 420
 421         br_mrp_switchdev_del(br, mrp);
 422
 423         /* Reset the ports */
 424         p = rtnl_dereference(mrp->p_port);
 425         if (p) {
 426                 spin_lock_bh(&br->lock);
 427                 state = netif_running(br->dev) ?
 428                                 BR_STATE_FORWARDING : BR_STATE_DISABLED;
 429                 p->state = state;
 430                 p->flags &= ~BR_MRP_AWARE;
 431                 spin_unlock_bh(&br->lock);
 432                 br_mrp_port_switchdev_set_state(p, state);
 433                 rcu_assign_pointer(mrp->p_port, NULL);
 434         }
 435
 436         p = rtnl_dereference(mrp->s_port);
 437         if (p) {
 438                 spin_lock_bh(&br->lock);
 439                 state = netif_running(br->dev) ?
 440                                 BR_STATE_FORWARDING : BR_STATE_DISABLED;
 441                 p->state = state;
 442                 p->flags &= ~BR_MRP_AWARE;
 443                 spin_unlock_bh(&br->lock);
 444                 br_mrp_port_switchdev_set_state(p, state);
 445                 rcu_assign_pointer(mrp->s_port, NULL);
 446         }
 447
 448         p = rtnl_dereference(mrp->i_port);
 449         if (p) {
 450                 spin_lock_bh(&br->lock);
 451                 state = netif_running(br->dev) ?
 452                                 BR_STATE_FORWARDING : BR_STATE_DISABLED;
 453                 p->state = state;
 454                 p->flags &= ~BR_MRP_AWARE;
 455                 spin_unlock_bh(&br->lock);
 456                 br_mrp_port_switchdev_set_state(p, state);
 457                 rcu_assign_pointer(mrp->i_port, NULL);
 458         }
 459
 460         hlist_del_rcu(&mrp->list);
 461         kfree_rcu(mrp, rcu);
 462
 463         if (hlist_empty(&br->mrp_list))
 464                 br_del_frame(br, &mrp_frame_type);
 465 }
 466
 467 /* Adds a new MRP instance.
 468  * note: called under rtnl_lock
 469  */
 470 int br_mrp_add(struct net_bridge *br, struct br_mrp_instance *instance)
 471 {
 472         struct net_bridge_port *p;
 473         struct br_mrp *mrp;
 474         int err;
 475
 476         /* If the ring exists, it is not possible to create another one with the
 477          * same ring_id
 478          */
 479         mrp = br_mrp_find_id(br, instance->ring_id);
 480         if (mrp)
 481                 return -EINVAL;
 482
 483         if (!br_mrp_get_port(br, instance->p_ifindex) ||
 484             !br_mrp_get_port(br, instance->s_ifindex))
 485                 return -EINVAL;
 486
 487         /* It is not possible to have the same port part of multiple rings */
 488         if (!br_mrp_unique_ifindex(br, instance->p_ifindex) ||
 489             !br_mrp_unique_ifindex(br, instance->s_ifindex))
 490                 return -EINVAL;
 491
 492         mrp = kzalloc(sizeof(*mrp), GFP_KERNEL);
 493         if (!mrp)
 494                 return -ENOMEM;
 495
 496         mrp->ring_id = instance->ring_id;
 497         mrp->prio = instance->prio;
 498
 499         p = br_mrp_get_port(br, instance->p_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->p_port, p);
 505
 506         p = br_mrp_get_port(br, instance->s_ifindex);
 507         spin_lock_bh(&br->lock);
 508         p->state = BR_STATE_FORWARDING;
 509         p->flags |= BR_MRP_AWARE;
 510         spin_unlock_bh(&br->lock);
 511         rcu_assign_pointer(mrp->s_port, p);
 512
 513         if (hlist_empty(&br->mrp_list))
 514                 br_add_frame(br, &mrp_frame_type);
 515
 516         INIT_DELAYED_WORK(&mrp->test_work, br_mrp_test_work_expired);
 517         INIT_DELAYED_WORK(&mrp->in_test_work, br_mrp_in_test_work_expired);
 518         hlist_add_tail_rcu(&mrp->list, &br->mrp_list);
 519
 520         err = br_mrp_switchdev_add(br, mrp);
 521         if (err)
 522                 goto delete_mrp;
 523
 524         return 0;
 525
 526 delete_mrp:
 527         br_mrp_del_impl(br, mrp);
 528
 529         return err;
 530 }
 531
 532 /* Deletes the MRP instance from which the port is part of
 533  * note: called under rtnl_lock
 534  */
 535 void br_mrp_port_del(struct net_bridge *br, struct net_bridge_port *p)
 536 {
 537         struct br_mrp *mrp = br_mrp_find_port(br, p);
 538
 539         /* If the port is not part of a MRP instance just bail out */
 540         if (!mrp)
 541                 return;
 542
 543         br_mrp_del_impl(br, mrp);
 544 }
 545
 546 /* Deletes existing MRP instance based on ring_id
 547  * note: called under rtnl_lock
 548  */
 549 int br_mrp_del(struct net_bridge *br, struct br_mrp_instance *instance)
 550 {
 551         struct br_mrp *mrp = br_mrp_find_id(br, instance->ring_id);
 552
 553         if (!mrp)
 554                 return -EINVAL;
 555
 556         br_mrp_del_impl(br, mrp);
 557
 558         return 0;
 559 }
 560
 561 /* Set port state, port state can be forwarding, blocked or disabled
 562  * note: already called with rtnl_lock
 563  */
 564 int br_mrp_set_port_state(struct net_bridge_port *p,
 565                           enum br_mrp_port_state_type state)
 566 {
 567         u32 port_state;
 568
 569         if (!p || !(p->flags & BR_MRP_AWARE))
 570                 return -EINVAL;
 571
 572         spin_lock_bh(&p->br->lock);
 573
 574         if (state == BR_MRP_PORT_STATE_FORWARDING)
 575                 port_state = BR_STATE_FORWARDING;
 576         else
 577                 port_state = BR_STATE_BLOCKING;
 578
 579         p->state = port_state;
 580         spin_unlock_bh(&p->br->lock);
 581
 582         br_mrp_port_switchdev_set_state(p, port_state);
 583
 584         return 0;
 585 }
 586
 587 /* Set port role, port role can be primary or secondary
 588  * note: already called with rtnl_lock
 589  */
 590 int br_mrp_set_port_role(struct net_bridge_port *p,
 591                          enum br_mrp_port_role_type role)
 592 {
 593         struct br_mrp *mrp;
 594
 595         if (!p || !(p->flags & BR_MRP_AWARE))
 596                 return -EINVAL;
 597
 598         mrp = br_mrp_find_port(p->br, p);
 599
 600         if (!mrp)
 601                 return -EINVAL;
 602
 603         switch (role) {
 604         case BR_MRP_PORT_ROLE_PRIMARY:
 605                 rcu_assign_pointer(mrp->p_port, p);
 606                 break;
 607         case BR_MRP_PORT_ROLE_SECONDARY:
 608                 rcu_assign_pointer(mrp->s_port, p);
 609                 break;
 610         default:
 611                 return -EINVAL;
 612         }
 613
 614         br_mrp_port_switchdev_set_role(p, role);
 615
 616         return 0;
 617 }
 618
 619 /* Set ring state, ring state can be only Open or Closed
 620  * note: already called with rtnl_lock
 621  */
 622 int br_mrp_set_ring_state(struct net_bridge *br,
 623                           struct br_mrp_ring_state *state)
 624 {
 625         struct br_mrp *mrp = br_mrp_find_id(br, state->ring_id);
 626
 627         if (!mrp)
 628                 return -EINVAL;
 629
 630         if (mrp->ring_state == BR_MRP_RING_STATE_CLOSED &&
 631             state->ring_state != BR_MRP_RING_STATE_CLOSED)
 632                 mrp->ring_transitions++;
 633
 634         mrp->ring_state = state->ring_state;
 635
 636         br_mrp_switchdev_set_ring_state(br, mrp, state->ring_state);
 637
 638         return 0;
 639 }
 640
 641 /* Set ring role, ring role can be only MRM(Media Redundancy Manager) or
 642  * MRC(Media Redundancy Client).
 643  * note: already called with rtnl_lock
 644  */
 645 int br_mrp_set_ring_role(struct net_bridge *br,
 646                          struct br_mrp_ring_role *role)
 647 {
 648         struct br_mrp *mrp = br_mrp_find_id(br, role->ring_id);
 649         enum br_mrp_hw_support support;
 650
 651         if (!mrp)
 652                 return -EINVAL;
 653
 654         mrp->ring_role = role->ring_role;
 655
 656         /* If there is an error just bailed out */
 657         support = br_mrp_switchdev_set_ring_role(br, mrp, role->ring_role);
 658         if (support == BR_MRP_NONE)
 659                 return -EOPNOTSUPP;
 660
 661         /* Now detect if the HW actually applied the role or not. If the HW
 662          * applied the role it means that the SW will not to do those operations
 663          * anymore. For example if the role ir MRM then the HW will notify the
 664          * SW when ring is open, but if the is not pushed to the HW the SW will
 665          * need to detect when the ring is open
 666          */
 667         mrp->ring_role_offloaded = support == BR_MRP_SW ? 0 : 1;
 668
 669         return 0;
 670 }
 671
 672 /* Start to generate or monitor MRP test frames, the frames are generated by
 673  * HW and if it fails, they are generated by the SW.
 674  * note: already called with rtnl_lock
 675  */
 676 int br_mrp_start_test(struct net_bridge *br,
 677                       struct br_mrp_start_test *test)
 678 {
 679         struct br_mrp *mrp = br_mrp_find_id(br, test->ring_id);
 680         enum br_mrp_hw_support support;
 681
 682         if (!mrp)
 683                 return -EINVAL;
 684
 685         /* Try to push it to the HW and if it fails then continue with SW
 686          * implementation and if that also fails then return error.
 687          */
 688         support = br_mrp_switchdev_send_ring_test(br, mrp, test->interval,
 689                                                   test->max_miss, test->period,
 690                                                   test->monitor);
 691         if (support == BR_MRP_NONE)
 692                 return -EOPNOTSUPP;
 693
 694         if (support == BR_MRP_HW)
 695                 return 0;
 696
 697         mrp->test_interval = test->interval;
 698         mrp->test_end = jiffies + usecs_to_jiffies(test->period);
 699         mrp->test_max_miss = test->max_miss;
 700         mrp->test_monitor = test->monitor;
 701         mrp->test_count_miss = 0;
 702         queue_delayed_work(system_wq, &mrp->test_work,
 703                            usecs_to_jiffies(test->interval));
 704
 705         return 0;
 706 }
 707
 708 /* Set in state, int state can be only Open or Closed
 709  * note: already called with rtnl_lock
 710  */
 711 int br_mrp_set_in_state(struct net_bridge *br, struct br_mrp_in_state *state)
 712 {
 713         struct br_mrp *mrp = br_mrp_find_in_id(br, state->in_id);
 714
 715         if (!mrp)
 716                 return -EINVAL;
 717
 718         if (mrp->in_state == BR_MRP_IN_STATE_CLOSED &&
 719             state->in_state != BR_MRP_IN_STATE_CLOSED)
 720                 mrp->in_transitions++;
 721
 722         mrp->in_state = state->in_state;
 723
 724         br_mrp_switchdev_set_in_state(br, mrp, state->in_state);
 725
 726         return 0;
 727 }
 728
 729 /* Set in role, in role can be only MIM(Media Interconnection Manager) or
 730  * MIC(Media Interconnection Client).
 731  * note: already called with rtnl_lock
 732  */
 733 int br_mrp_set_in_role(struct net_bridge *br, struct br_mrp_in_role *role)
 734 {
 735         struct br_mrp *mrp = br_mrp_find_id(br, role->ring_id);
 736         enum br_mrp_hw_support support;
 737         struct net_bridge_port *p;
 738
 739         if (!mrp)
 740                 return -EINVAL;
 741
 742         if (!br_mrp_get_port(br, role->i_ifindex))
 743                 return -EINVAL;
 744
 745         if (role->in_role == BR_MRP_IN_ROLE_DISABLED) {
 746                 u8 state;
 747
 748                 /* It is not allowed to disable a port that doesn't exist */
 749                 p = rtnl_dereference(mrp->i_port);
 750                 if (!p)
 751                         return -EINVAL;
 752
 753                 /* Stop the generating MRP_InTest frames */
 754                 cancel_delayed_work_sync(&mrp->in_test_work);
 755                 br_mrp_switchdev_send_in_test(br, mrp, 0, 0, 0);
 756
 757                 /* Remove the port */
 758                 spin_lock_bh(&br->lock);
 759                 state = netif_running(br->dev) ?
 760                                 BR_STATE_FORWARDING : BR_STATE_DISABLED;
 761                 p->state = state;
 762                 p->flags &= ~BR_MRP_AWARE;
 763                 spin_unlock_bh(&br->lock);
 764                 br_mrp_port_switchdev_set_state(p, state);
 765                 rcu_assign_pointer(mrp->i_port, NULL);
 766
 767                 mrp->in_role = role->in_role;
 768                 mrp->in_id = 0;
 769
 770                 return 0;
 771         }
 772
 773         /* It is not possible to have the same port part of multiple rings */
 774         if (!br_mrp_unique_ifindex(br, role->i_ifindex))
 775                 return -EINVAL;
 776
 777         /* It is not allowed to set a different interconnect port if the mrp
 778          * instance has already one. First it needs to be disabled and after
 779          * that set the new port
 780          */
 781         if (rcu_access_pointer(mrp->i_port))
 782                 return -EINVAL;
 783
 784         p = br_mrp_get_port(br, role->i_ifindex);
 785         spin_lock_bh(&br->lock);
 786         p->state = BR_STATE_FORWARDING;
 787         p->flags |= BR_MRP_AWARE;
 788         spin_unlock_bh(&br->lock);
 789         rcu_assign_pointer(mrp->i_port, p);
 790
 791         mrp->in_role = role->in_role;
 792         mrp->in_id = role->in_id;
 793
 794         /* If there is an error just bailed out */
 795         support = br_mrp_switchdev_set_in_role(br, mrp, role->in_id,
 796                                                role->ring_id, role->in_role);
 797         if (support == BR_MRP_NONE)
 798                 return -EOPNOTSUPP;
 799
 800         /* Now detect if the HW actually applied the role or not. If the HW
 801          * applied the role it means that the SW will not to do those operations
 802          * anymore. For example if the role is MIM then the HW will notify the
 803          * SW when interconnect ring is open, but if the is not pushed to the HW
 804          * the SW will need to detect when the interconnect ring is open.
 805          */
 806         mrp->in_role_offloaded = support == BR_MRP_SW ? 0 : 1;
 807
 808         return 0;
 809 }
 810
 811 /* Start to generate MRP_InTest frames, the frames are generated by
 812  * HW and if it fails, they are generated by the SW.
 813  * note: already called with rtnl_lock
 814  */
 815 int br_mrp_start_in_test(struct net_bridge *br,
 816                          struct br_mrp_start_in_test *in_test)
 817 {
 818         struct br_mrp *mrp = br_mrp_find_in_id(br, in_test->in_id);
 819         enum br_mrp_hw_support support;
 820
 821         if (!mrp)
 822                 return -EINVAL;
 823
 824         if (mrp->in_role != BR_MRP_IN_ROLE_MIM)
 825                 return -EINVAL;
 826
 827         /* Try to push it to the HW and if it fails then continue with SW
 828          * implementation and if that also fails then return error.
 829          */
 830         support =  br_mrp_switchdev_send_in_test(br, mrp, in_test->interval,
 831                                                  in_test->max_miss,
 832                                                  in_test->period);
 833         if (support == BR_MRP_NONE)
 834                 return -EOPNOTSUPP;
 835
 836         if (support == BR_MRP_HW)
 837                 return 0;
 838
 839         mrp->in_test_interval = in_test->interval;
 840         mrp->in_test_end = jiffies + usecs_to_jiffies(in_test->period);
 841         mrp->in_test_max_miss = in_test->max_miss;
 842         mrp->in_test_count_miss = 0;
 843         queue_delayed_work(system_wq, &mrp->in_test_work,
 844                            usecs_to_jiffies(in_test->interval));
 845
 846         return 0;
 847 }
 848
 849 /* Determine if the frame type is a ring frame */
 850 static bool br_mrp_ring_frame(struct sk_buff *skb)
 851 {
 852         const struct br_mrp_tlv_hdr *hdr;
 853         struct br_mrp_tlv_hdr _hdr;
 854
 855         hdr = skb_header_pointer(skb, sizeof(uint16_t), sizeof(_hdr), &_hdr);
 856         if (!hdr)
 857                 return false;
 858
 859         if (hdr->type == BR_MRP_TLV_HEADER_RING_TEST ||
 860             hdr->type == BR_MRP_TLV_HEADER_RING_TOPO ||
 861             hdr->type == BR_MRP_TLV_HEADER_RING_LINK_DOWN ||
 862             hdr->type == BR_MRP_TLV_HEADER_RING_LINK_UP ||
 863             hdr->type == BR_MRP_TLV_HEADER_OPTION)
 864                 return true;
 865
 866         return false;
 867 }
 868
 869 /* Determine if the frame type is an interconnect frame */
 870 static bool br_mrp_in_frame(struct sk_buff *skb)
 871 {
 872         const struct br_mrp_tlv_hdr *hdr;
 873         struct br_mrp_tlv_hdr _hdr;
 874
 875         hdr = skb_header_pointer(skb, sizeof(uint16_t), sizeof(_hdr), &_hdr);
 876         if (!hdr)
 877                 return false;
 878
 879         if (hdr->type == BR_MRP_TLV_HEADER_IN_TEST ||
 880             hdr->type == BR_MRP_TLV_HEADER_IN_TOPO ||
 881             hdr->type == BR_MRP_TLV_HEADER_IN_LINK_DOWN ||
 882             hdr->type == BR_MRP_TLV_HEADER_IN_LINK_UP ||
 883             hdr->type == BR_MRP_TLV_HEADER_IN_LINK_STATUS)
 884                 return true;
 885
 886         return false;
 887 }
 888
 889 /* Process only MRP Test frame. All the other MRP frames are processed by
 890  * userspace application
 891  * note: already called with rcu_read_lock
 892  */
 893 static void br_mrp_mrm_process(struct br_mrp *mrp, struct net_bridge_port *port,
 894                                struct sk_buff *skb)
 895 {
 896         const struct br_mrp_tlv_hdr *hdr;
 897         struct br_mrp_tlv_hdr _hdr;
 898
 899         /* Each MRP header starts with a version field which is 16 bits.
 900          * Therefore skip the version and get directly the TLV header.
 901          */
 902         hdr = skb_header_pointer(skb, sizeof(uint16_t), sizeof(_hdr), &_hdr);
 903         if (!hdr)
 904                 return;
 905
 906         if (hdr->type != BR_MRP_TLV_HEADER_RING_TEST)
 907                 return;
 908
 909         mrp->test_count_miss = 0;
 910
 911         /* Notify the userspace that the ring is closed only when the ring is
 912          * not closed
 913          */
 914         if (mrp->ring_state != BR_MRP_RING_STATE_CLOSED)
 915                 br_mrp_ring_port_open(port->dev, false);
 916 }
 917
 918 /* Determine if the test hdr has a better priority than the node */
 919 static bool br_mrp_test_better_than_own(struct br_mrp *mrp,
 920                                         struct net_bridge *br,
 921                                         const struct br_mrp_ring_test_hdr *hdr)
 922 {
 923         u16 prio = be16_to_cpu(hdr->prio);
 924
 925         if (prio < mrp->prio ||
 926             (prio == mrp->prio &&
 927             ether_addr_to_u64(hdr->sa) < ether_addr_to_u64(br->dev->dev_addr)))
 928                 return true;
 929
 930         return false;
 931 }
 932
 933 /* Process only MRP Test frame. All the other MRP frames are processed by
 934  * userspace application
 935  * note: already called with rcu_read_lock
 936  */
 937 static void br_mrp_mra_process(struct br_mrp *mrp, struct net_bridge *br,
 938                                struct net_bridge_port *port,
 939                                struct sk_buff *skb)
 940 {
 941         const struct br_mrp_ring_test_hdr *test_hdr;
 942         struct br_mrp_ring_test_hdr _test_hdr;
 943         const struct br_mrp_tlv_hdr *hdr;
 944         struct br_mrp_tlv_hdr _hdr;
 945
 946         /* Each MRP header starts with a version field which is 16 bits.
 947          * Therefore skip the version and get directly the TLV header.
 948          */
 949         hdr = skb_header_pointer(skb, sizeof(uint16_t), sizeof(_hdr), &_hdr);
 950         if (!hdr)
 951                 return;
 952
 953         if (hdr->type != BR_MRP_TLV_HEADER_RING_TEST)
 954                 return;
 955
 956         test_hdr = skb_header_pointer(skb, sizeof(uint16_t) + sizeof(_hdr),
 957                                       sizeof(_test_hdr), &_test_hdr);
 958         if (!test_hdr)
 959                 return;
 960
 961         /* Only frames that have a better priority than the node will
 962          * clear the miss counter because otherwise the node will need to behave
 963          * as MRM.
 964          */
 965         if (br_mrp_test_better_than_own(mrp, br, test_hdr))
 966                 mrp->test_count_miss = 0;
 967 }
 968
 969 /* Process only MRP InTest frame. All the other MRP frames are processed by
 970  * userspace application
 971  * note: already called with rcu_read_lock
 972  */
 973 static bool br_mrp_mim_process(struct br_mrp *mrp, struct net_bridge_port *port,
 974                                struct sk_buff *skb)
 975 {
 976         const struct br_mrp_in_test_hdr *in_hdr;
 977         struct br_mrp_in_test_hdr _in_hdr;
 978         const struct br_mrp_tlv_hdr *hdr;
 979         struct br_mrp_tlv_hdr _hdr;
 980
 981         /* Each MRP header starts with a version field which is 16 bits.
 982          * Therefore skip the version and get directly the TLV header.
 983          */
 984         hdr = skb_header_pointer(skb, sizeof(uint16_t), sizeof(_hdr), &_hdr);
 985         if (!hdr)
 986                 return false;
 987
 988         /* The check for InTest frame type was already done */
 989         in_hdr = skb_header_pointer(skb, sizeof(uint16_t) + sizeof(_hdr),
 990                                     sizeof(_in_hdr), &_in_hdr);
 991         if (!in_hdr)
 992                 return false;
 993
 994         /* It needs to process only it's own InTest frames. */
 995         if (mrp->in_id != ntohs(in_hdr->id))
 996                 return false;
 997
 998         mrp->in_test_count_miss = 0;
 999
1000         /* Notify the userspace that the ring is closed only when the ring is
1001          * not closed
1002          */
1003         if (mrp->in_state != BR_MRP_IN_STATE_CLOSED)
1004                 br_mrp_in_port_open(port->dev, false);
1005
1006         return true;
1007 }
1008
1009 /* Get the MRP frame type
1010  * note: already called with rcu_read_lock
1011  */
1012 static u8 br_mrp_get_frame_type(struct sk_buff *skb)
1013 {
1014         const struct br_mrp_tlv_hdr *hdr;
1015         struct br_mrp_tlv_hdr _hdr;
1016
1017         /* Each MRP header starts with a version field which is 16 bits.
1018          * Therefore skip the version and get directly the TLV header.
1019          */
1020         hdr = skb_header_pointer(skb, sizeof(uint16_t), sizeof(_hdr), &_hdr);
1021         if (!hdr)
1022                 return 0xff;
1023
1024         return hdr->type;
1025 }
1026
1027 static bool br_mrp_mrm_behaviour(struct br_mrp *mrp)
1028 {
1029         if (mrp->ring_role == BR_MRP_RING_ROLE_MRM ||
1030             (mrp->ring_role == BR_MRP_RING_ROLE_MRA && !mrp->test_monitor))
1031                 return true;
1032
1033         return false;
1034 }
1035
1036 static bool br_mrp_mrc_behaviour(struct br_mrp *mrp)
1037 {
1038         if (mrp->ring_role == BR_MRP_RING_ROLE_MRC ||
1039             (mrp->ring_role == BR_MRP_RING_ROLE_MRA && mrp->test_monitor))
1040                 return true;
1041
1042         return false;
1043 }
1044
1045 /* This will just forward the frame to the other mrp ring ports, depending on
1046  * the frame type, ring role and interconnect role
1047  * note: already called with rcu_read_lock
1048  */
1049 static int br_mrp_rcv(struct net_bridge_port *p,
1050                       struct sk_buff *skb, struct net_device *dev)
1051 {
1052         struct net_bridge_port *p_port, *s_port, *i_port = NULL;
1053         struct net_bridge_port *p_dst, *s_dst, *i_dst = NULL;
1054         struct net_bridge *br;
1055         struct br_mrp *mrp;
1056
1057         /* If port is disabled don't accept any frames */
1058         if (p->state == BR_STATE_DISABLED)
1059                 return 0;
1060
1061         br = p->br;
1062         mrp =  br_mrp_find_port(br, p);
1063         if (unlikely(!mrp))
1064                 return 0;
1065
1066         p_port = rcu_dereference(mrp->p_port);
1067         if (!p_port)
1068                 return 0;
1069         p_dst = p_port;
1070
1071         s_port = rcu_dereference(mrp->s_port);
1072         if (!s_port)
1073                 return 0;
1074         s_dst = s_port;
1075
1076         /* If the frame is a ring frame then it is not required to check the
1077          * interconnect role and ports to process or forward the frame
1078          */
1079         if (br_mrp_ring_frame(skb)) {
1080                 /* If the role is MRM then don't forward the frames */
1081                 if (mrp->ring_role == BR_MRP_RING_ROLE_MRM) {
1082                         br_mrp_mrm_process(mrp, p, skb);
1083                         goto no_forward;
1084                 }
1085
1086                 /* If the role is MRA then don't forward the frames if it
1087                  * behaves as MRM node
1088                  */
1089                 if (mrp->ring_role == BR_MRP_RING_ROLE_MRA) {
1090                         if (!mrp->test_monitor) {
1091                                 br_mrp_mrm_process(mrp, p, skb);
1092                                 goto no_forward;
1093                         }
1094
1095                         br_mrp_mra_process(mrp, br, p, skb);
1096                 }
1097
1098                 goto forward;
1099         }
1100
1101         if (br_mrp_in_frame(skb)) {
1102                 u8 in_type = br_mrp_get_frame_type(skb);
1103
1104                 i_port = rcu_dereference(mrp->i_port);
1105                 i_dst = i_port;
1106
1107                 /* If the ring port is in block state it should not forward
1108                  * In_Test frames
1109                  */
1110                 if (br_mrp_is_ring_port(p_port, s_port, p) &&
1111                     p->state == BR_STATE_BLOCKING &&
1112                     in_type == BR_MRP_TLV_HEADER_IN_TEST)
1113                         goto no_forward;
1114
1115                 /* Nodes that behaves as MRM needs to stop forwarding the
1116                  * frames in case the ring is closed, otherwise will be a loop.
1117                  * In this case the frame is no forward between the ring ports.
1118                  */
1119                 if (br_mrp_mrm_behaviour(mrp) &&
1120                     br_mrp_is_ring_port(p_port, s_port, p) &&
1121                     (s_port->state != BR_STATE_FORWARDING ||
1122                      p_port->state != BR_STATE_FORWARDING)) {
1123                         p_dst = NULL;
1124                         s_dst = NULL;
1125                 }
1126
1127                 /* A node that behaves as MRC and doesn't have a interconnect
1128                  * role then it should forward all frames between the ring ports
1129                  * because it doesn't have an interconnect port
1130                  */
1131                 if (br_mrp_mrc_behaviour(mrp) &&
1132                     mrp->in_role == BR_MRP_IN_ROLE_DISABLED)
1133                         goto forward;
1134
1135                 if (mrp->in_role == BR_MRP_IN_ROLE_MIM) {
1136                         if (in_type == BR_MRP_TLV_HEADER_IN_TEST) {
1137                                 /* MIM should not forward it's own InTest
1138                                  * frames
1139                                  */
1140                                 if (br_mrp_mim_process(mrp, p, skb)) {
1141                                         goto no_forward;
1142                                 } else {
1143                                         if (br_mrp_is_ring_port(p_port, s_port,
1144                                                                 p))
1145                                                 i_dst = NULL;
1146
1147                                         if (br_mrp_is_in_port(i_port, p))
1148                                                 goto no_forward;
1149                                 }
1150                         } else {
1151                                 /* MIM should forward IntLinkChange/Status and
1152                                  * IntTopoChange between ring ports but MIM
1153                                  * should not forward IntLinkChange/Status and
1154                                  * IntTopoChange if the frame was received at
1155                                  * the interconnect port
1156                                  */
1157                                 if (br_mrp_is_ring_port(p_port, s_port, p))
1158                                         i_dst = NULL;
1159
1160                                 if (br_mrp_is_in_port(i_port, p))
1161                                         goto no_forward;
1162                         }
1163                 }
1164
1165                 if (mrp->in_role == BR_MRP_IN_ROLE_MIC) {
1166                         /* MIC should forward InTest frames on all ports
1167                          * regardless of the received port
1168                          */
1169                         if (in_type == BR_MRP_TLV_HEADER_IN_TEST)
1170                                 goto forward;
1171
1172                         /* MIC should forward IntLinkChange frames only if they
1173                          * are received on ring ports to all the ports
1174                          */
1175                         if (br_mrp_is_ring_port(p_port, s_port, p) &&
1176                             (in_type == BR_MRP_TLV_HEADER_IN_LINK_UP ||
1177                              in_type == BR_MRP_TLV_HEADER_IN_LINK_DOWN))
1178                                 goto forward;
1179
1180                         /* MIC should forward IntLinkStatus frames only to
1181                          * interconnect port if it was received on a ring port.
1182                          * If it is received on interconnect port then, it
1183                          * should be forward on both ring ports
1184                          */
1185                         if (br_mrp_is_ring_port(p_port, s_port, p) &&
1186                             in_type == BR_MRP_TLV_HEADER_IN_LINK_STATUS) {
1187                                 p_dst = NULL;
1188                                 s_dst = NULL;
1189                         }
1190
1191                         /* Should forward the InTopo frames only between the
1192                          * ring ports
1193                          */
1194                         if (in_type == BR_MRP_TLV_HEADER_IN_TOPO) {
1195                                 i_dst = NULL;
1196                                 goto forward;
1197                         }
1198
1199                         /* In all the other cases don't forward the frames */
1200                         goto no_forward;
1201                 }
1202         }
1203
1204 forward:
1205         if (p_dst)
1206                 br_forward(p_dst, skb, true, false);
1207         if (s_dst)
1208                 br_forward(s_dst, skb, true, false);
1209         if (i_dst)
1210                 br_forward(i_dst, skb, true, false);
1211
1212 no_forward:
1213         return 1;
1214 }
1215
1216 /* Check if the frame was received on a port that is part of MRP ring
1217  * and if the frame has MRP eth. In that case process the frame otherwise do
1218  * normal forwarding.
1219  * note: already called with rcu_read_lock
1220  */
1221 static int br_mrp_process(struct net_bridge_port *p, struct sk_buff *skb)
1222 {
1223         /* If there is no MRP instance do normal forwarding */
1224         if (likely(!(p->flags & BR_MRP_AWARE)))
1225                 goto out;
1226
1227         return br_mrp_rcv(p, skb, p->dev);
1228 out:
1229         return 0;
1230 }
1231
1232 bool br_mrp_enabled(struct net_bridge *br)
1233 {
1234         return !hlist_empty(&br->mrp_list);
1235 }