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
   8 static struct net_bridge_port *br_mrp_get_port(struct net_bridge *br,
   9                                                u32 ifindex)
  10 {
  11         struct net_bridge_port *res = NULL;
  12         struct net_bridge_port *port;
  13
  14         list_for_each_entry(port, &br->port_list, list) {
  15                 if (port->dev->ifindex == ifindex) {
  16                         res = port;
  17                         break;
  18                 }
  19         }
  20
  21         return res;
  22 }
  23
  24 static struct br_mrp *br_mrp_find_id(struct net_bridge *br, u32 ring_id)
  25 {
  26         struct br_mrp *res = NULL;
  27         struct br_mrp *mrp;
  28
  29         list_for_each_entry_rcu(mrp, &br->mrp_list, list,
  30                                 lockdep_rtnl_is_held()) {
  31                 if (mrp->ring_id == ring_id) {
  32                         res = mrp;
  33                         break;
  34                 }
  35         }
  36
  37         return res;
  38 }
  39
  40 static struct br_mrp *br_mrp_find_port(struct net_bridge *br,
  41                                        struct net_bridge_port *p)
  42 {
  43         struct br_mrp *res = NULL;
  44         struct br_mrp *mrp;
  45
  46         list_for_each_entry_rcu(mrp, &br->mrp_list, list,
  47                                 lockdep_rtnl_is_held()) {
  48                 if (rcu_access_pointer(mrp->p_port) == p ||
  49                     rcu_access_pointer(mrp->s_port) == p) {
  50                         res = mrp;
  51                         break;
  52                 }
  53         }
  54
  55         return res;
  56 }
  57
  58 static int br_mrp_next_seq(struct br_mrp *mrp)
  59 {
  60         mrp->seq_id++;
  61         return mrp->seq_id;
  62 }
  63
  64 static struct sk_buff *br_mrp_skb_alloc(struct net_bridge_port *p,
  65                                         const u8 *src, const u8 *dst)
  66 {
  67         struct ethhdr *eth_hdr;
  68         struct sk_buff *skb;
  69         u16 *version;
  70
  71         skb = dev_alloc_skb(MRP_MAX_FRAME_LENGTH);
  72         if (!skb)
  73                 return NULL;
  74
  75         skb->dev = p->dev;
  76         skb->protocol = htons(ETH_P_MRP);
  77         skb->priority = MRP_FRAME_PRIO;
  78         skb_reserve(skb, sizeof(*eth_hdr));
  79
  80         eth_hdr = skb_push(skb, sizeof(*eth_hdr));
  81         ether_addr_copy(eth_hdr->h_dest, dst);
  82         ether_addr_copy(eth_hdr->h_source, src);
  83         eth_hdr->h_proto = htons(ETH_P_MRP);
  84
  85         version = skb_put(skb, sizeof(*version));
  86         *version = cpu_to_be16(MRP_VERSION);
  87
  88         return skb;
  89 }
  90
  91 static void br_mrp_skb_tlv(struct sk_buff *skb,
  92                            enum br_mrp_tlv_header_type type,
  93                            u8 length)
  94 {
  95         struct br_mrp_tlv_hdr *hdr;
  96
  97         hdr = skb_put(skb, sizeof(*hdr));
  98         hdr->type = type;
  99         hdr->length = length;
 100 }
 101
 102 static void br_mrp_skb_common(struct sk_buff *skb, struct br_mrp *mrp)
 103 {
 104         struct br_mrp_common_hdr *hdr;
 105
 106         br_mrp_skb_tlv(skb, BR_MRP_TLV_HEADER_COMMON, sizeof(*hdr));
 107
 108         hdr = skb_put(skb, sizeof(*hdr));
 109         hdr->seq_id = cpu_to_be16(br_mrp_next_seq(mrp));
 110         memset(hdr->domain, 0xff, MRP_DOMAIN_UUID_LENGTH);
 111 }
 112
 113 static struct sk_buff *br_mrp_alloc_test_skb(struct br_mrp *mrp,
 114                                              struct net_bridge_port *p,
 115                                              enum br_mrp_port_role_type port_role)
 116 {
 117         struct br_mrp_ring_test_hdr *hdr = NULL;
 118         struct sk_buff *skb = NULL;
 119
 120         if (!p)
 121                 return NULL;
 122
 123         skb = br_mrp_skb_alloc(p, p->dev->dev_addr, mrp_test_dmac);
 124         if (!skb)
 125                 return NULL;
 126
 127         br_mrp_skb_tlv(skb, BR_MRP_TLV_HEADER_RING_TEST, sizeof(*hdr));
 128         hdr = skb_put(skb, sizeof(*hdr));
 129
 130         hdr->prio = cpu_to_be16(MRP_DEFAULT_PRIO);
 131         ether_addr_copy(hdr->sa, p->br->dev->dev_addr);
 132         hdr->port_role = cpu_to_be16(port_role);
 133         hdr->state = cpu_to_be16(mrp->ring_state);
 134         hdr->transitions = cpu_to_be16(mrp->ring_transitions);
 135         hdr->timestamp = cpu_to_be32(jiffies_to_msecs(jiffies));
 136
 137         br_mrp_skb_common(skb, mrp);
 138         br_mrp_skb_tlv(skb, BR_MRP_TLV_HEADER_END, 0x0);
 139
 140         return skb;
 141 }
 142
 143 static void br_mrp_test_work_expired(struct work_struct *work)
 144 {
 145         struct delayed_work *del_work = to_delayed_work(work);
 146         struct br_mrp *mrp = container_of(del_work, struct br_mrp, test_work);
 147         struct net_bridge_port *p;
 148         bool notify_open = false;
 149         struct sk_buff *skb;
 150
 151         if (time_before_eq(mrp->test_end, jiffies))
 152                 return;
 153
 154         if (mrp->test_count_miss < mrp->test_max_miss) {
 155                 mrp->test_count_miss++;
 156         } else {
 157                 /* Notify that the ring is open only if the ring state is
 158                  * closed, otherwise it would continue to notify at every
 159                  * interval.
 160                  */
 161                 if (mrp->ring_state == BR_MRP_RING_STATE_CLOSED)
 162                         notify_open = true;
 163         }
 164
 165         rcu_read_lock();
 166
 167         p = rcu_dereference(mrp->p_port);
 168         if (p) {
 169                 skb = br_mrp_alloc_test_skb(mrp, p, BR_MRP_PORT_ROLE_PRIMARY);
 170                 if (!skb)
 171                         goto out;
 172
 173                 skb_reset_network_header(skb);
 174                 dev_queue_xmit(skb);
 175
 176                 if (notify_open && !mrp->ring_role_offloaded)
 177                         br_mrp_port_open(p->dev, true);
 178         }
 179
 180         p = rcu_dereference(mrp->s_port);
 181         if (p) {
 182                 skb = br_mrp_alloc_test_skb(mrp, p, BR_MRP_PORT_ROLE_SECONDARY);
 183                 if (!skb)
 184                         goto out;
 185
 186                 skb_reset_network_header(skb);
 187                 dev_queue_xmit(skb);
 188
 189                 if (notify_open && !mrp->ring_role_offloaded)
 190                         br_mrp_port_open(p->dev, true);
 191         }
 192
 193 out:
 194         rcu_read_unlock();
 195
 196         queue_delayed_work(system_wq, &mrp->test_work,
 197                            usecs_to_jiffies(mrp->test_interval));
 198 }
 199
 200 /* Deletes the MRP instance.
 201  * note: called under rtnl_lock
 202  */
 203 static void br_mrp_del_impl(struct net_bridge *br, struct br_mrp *mrp)
 204 {
 205         struct net_bridge_port *p;
 206
 207         /* Stop sending MRP_Test frames */
 208         cancel_delayed_work_sync(&mrp->test_work);
 209         br_mrp_switchdev_send_ring_test(br, mrp, 0, 0, 0);
 210
 211         br_mrp_switchdev_del(br, mrp);
 212
 213         /* Reset the ports */
 214         p = rtnl_dereference(mrp->p_port);
 215         if (p) {
 216                 spin_lock_bh(&br->lock);
 217                 p->state = BR_STATE_FORWARDING;
 218                 p->flags &= ~BR_MRP_AWARE;
 219                 spin_unlock_bh(&br->lock);
 220                 br_mrp_port_switchdev_set_state(p, BR_STATE_FORWARDING);
 221                 rcu_assign_pointer(mrp->p_port, NULL);
 222         }
 223
 224         p = rtnl_dereference(mrp->s_port);
 225         if (p) {
 226                 spin_lock_bh(&br->lock);
 227                 p->state = BR_STATE_FORWARDING;
 228                 p->flags &= ~BR_MRP_AWARE;
 229                 spin_unlock_bh(&br->lock);
 230                 br_mrp_port_switchdev_set_state(p, BR_STATE_FORWARDING);
 231                 rcu_assign_pointer(mrp->s_port, NULL);
 232         }
 233
 234         list_del_rcu(&mrp->list);
 235         kfree_rcu(mrp, rcu);
 236 }
 237
 238 /* Adds a new MRP instance.
 239  * note: called under rtnl_lock
 240  */
 241 int br_mrp_add(struct net_bridge *br, struct br_mrp_instance *instance)
 242 {
 243         struct net_bridge_port *p;
 244         struct br_mrp *mrp;
 245         int err;
 246
 247         /* If the ring exists, it is not possible to create another one with the
 248          * same ring_id
 249          */
 250         mrp = br_mrp_find_id(br, instance->ring_id);
 251         if (mrp)
 252                 return -EINVAL;
 253
 254         if (!br_mrp_get_port(br, instance->p_ifindex) ||
 255             !br_mrp_get_port(br, instance->s_ifindex))
 256                 return -EINVAL;
 257
 258         mrp = kzalloc(sizeof(*mrp), GFP_KERNEL);
 259         if (!mrp)
 260                 return -ENOMEM;
 261
 262         mrp->ring_id = instance->ring_id;
 263
 264         p = br_mrp_get_port(br, instance->p_ifindex);
 265         spin_lock_bh(&br->lock);
 266         p->state = BR_STATE_FORWARDING;
 267         p->flags |= BR_MRP_AWARE;
 268         spin_unlock_bh(&br->lock);
 269         rcu_assign_pointer(mrp->p_port, p);
 270
 271         p = br_mrp_get_port(br, instance->s_ifindex);
 272         spin_lock_bh(&br->lock);
 273         p->state = BR_STATE_FORWARDING;
 274         p->flags |= BR_MRP_AWARE;
 275         spin_unlock_bh(&br->lock);
 276         rcu_assign_pointer(mrp->s_port, p);
 277
 278         INIT_DELAYED_WORK(&mrp->test_work, br_mrp_test_work_expired);
 279         list_add_tail_rcu(&mrp->list, &br->mrp_list);
 280
 281         err = br_mrp_switchdev_add(br, mrp);
 282         if (err)
 283                 goto delete_mrp;
 284
 285         return 0;
 286
 287 delete_mrp:
 288         br_mrp_del_impl(br, mrp);
 289
 290         return err;
 291 }
 292
 293 /* Deletes the MRP instance from which the port is part of
 294  * note: called under rtnl_lock
 295  */
 296 void br_mrp_port_del(struct net_bridge *br, struct net_bridge_port *p)
 297 {
 298         struct br_mrp *mrp = br_mrp_find_port(br, p);
 299
 300         /* If the port is not part of a MRP instance just bail out */
 301         if (!mrp)
 302                 return;
 303
 304         br_mrp_del_impl(br, mrp);
 305 }
 306
 307 /* Deletes existing MRP instance based on ring_id
 308  * note: called under rtnl_lock
 309  */
 310 int br_mrp_del(struct net_bridge *br, struct br_mrp_instance *instance)
 311 {
 312         struct br_mrp *mrp = br_mrp_find_id(br, instance->ring_id);
 313
 314         if (!mrp)
 315                 return -EINVAL;
 316
 317         br_mrp_del_impl(br, mrp);
 318
 319         return 0;
 320 }
 321
 322 /* Set port state, port state can be forwarding, blocked or disabled
 323  * note: already called with rtnl_lock
 324  */
 325 int br_mrp_set_port_state(struct net_bridge_port *p,
 326                           enum br_mrp_port_state_type state)
 327 {
 328         if (!p || !(p->flags & BR_MRP_AWARE))
 329                 return -EINVAL;
 330
 331         spin_lock_bh(&p->br->lock);
 332
 333         if (state == BR_MRP_PORT_STATE_FORWARDING)
 334                 p->state = BR_STATE_FORWARDING;
 335         else
 336                 p->state = BR_STATE_BLOCKING;
 337
 338         spin_unlock_bh(&p->br->lock);
 339
 340         br_mrp_port_switchdev_set_state(p, state);
 341
 342         return 0;
 343 }
 344
 345 /* Set port role, port role can be primary or secondary
 346  * note: already called with rtnl_lock
 347  */
 348 int br_mrp_set_port_role(struct net_bridge_port *p,
 349                          struct br_mrp_port_role *role)
 350 {
 351         struct br_mrp *mrp;
 352
 353         if (!p || !(p->flags & BR_MRP_AWARE))
 354                 return -EINVAL;
 355
 356         mrp = br_mrp_find_id(p->br, role->ring_id);
 357
 358         if (!mrp)
 359                 return -EINVAL;
 360
 361         if (role->role == BR_MRP_PORT_ROLE_PRIMARY)
 362                 rcu_assign_pointer(mrp->p_port, p);
 363         else
 364                 rcu_assign_pointer(mrp->s_port, p);
 365
 366         br_mrp_port_switchdev_set_role(p, role->role);
 367
 368         return 0;
 369 }
 370
 371 /* Set ring state, ring state can be only Open or Closed
 372  * note: already called with rtnl_lock
 373  */
 374 int br_mrp_set_ring_state(struct net_bridge *br,
 375                           struct br_mrp_ring_state *state)
 376 {
 377         struct br_mrp *mrp = br_mrp_find_id(br, state->ring_id);
 378
 379         if (!mrp)
 380                 return -EINVAL;
 381
 382         if (mrp->ring_state == BR_MRP_RING_STATE_CLOSED &&
 383             state->ring_state != BR_MRP_RING_STATE_CLOSED)
 384                 mrp->ring_transitions++;
 385
 386         mrp->ring_state = state->ring_state;
 387
 388         br_mrp_switchdev_set_ring_state(br, mrp, state->ring_state);
 389
 390         return 0;
 391 }
 392
 393 /* Set ring role, ring role can be only MRM(Media Redundancy Manager) or
 394  * MRC(Media Redundancy Client).
 395  * note: already called with rtnl_lock
 396  */
 397 int br_mrp_set_ring_role(struct net_bridge *br,
 398                          struct br_mrp_ring_role *role)
 399 {
 400         struct br_mrp *mrp = br_mrp_find_id(br, role->ring_id);
 401         int err;
 402
 403         if (!mrp)
 404                 return -EINVAL;
 405
 406         mrp->ring_role = role->ring_role;
 407
 408         /* If there is an error just bailed out */
 409         err = br_mrp_switchdev_set_ring_role(br, mrp, role->ring_role);
 410         if (err && err != -EOPNOTSUPP)
 411                 return err;
 412
 413         /* Now detect if the HW actually applied the role or not. If the HW
 414          * applied the role it means that the SW will not to do those operations
 415          * anymore. For example if the role ir MRM then the HW will notify the
 416          * SW when ring is open, but if the is not pushed to the HW the SW will
 417          * need to detect when the ring is open
 418          */
 419         mrp->ring_role_offloaded = err == -EOPNOTSUPP ? 0 : 1;
 420
 421         return 0;
 422 }
 423
 424 /* Start to generate MRP test frames, the frames are generated by HW and if it
 425  * fails, they are generated by the SW.
 426  * note: already called with rtnl_lock
 427  */
 428 int br_mrp_start_test(struct net_bridge *br,
 429                       struct br_mrp_start_test *test)
 430 {
 431         struct br_mrp *mrp = br_mrp_find_id(br, test->ring_id);
 432
 433         if (!mrp)
 434                 return -EINVAL;
 435
 436         /* Try to push it to the HW and if it fails then continue to generate in
 437          * SW and if that also fails then return error
 438          */
 439         if (!br_mrp_switchdev_send_ring_test(br, mrp, test->interval,
 440                                              test->max_miss, test->period))
 441                 return 0;
 442
 443         mrp->test_interval = test->interval;
 444         mrp->test_end = jiffies + usecs_to_jiffies(test->period);
 445         mrp->test_max_miss = test->max_miss;
 446         mrp->test_count_miss = 0;
 447         queue_delayed_work(system_wq, &mrp->test_work,
 448                            usecs_to_jiffies(test->interval));
 449
 450         return 0;
 451 }
 452
 453 /* Process only MRP Test frame. All the other MRP frames are processed by
 454  * userspace application
 455  * note: already called with rcu_read_lock
 456  */
 457 static void br_mrp_mrm_process(struct br_mrp *mrp, struct net_bridge_port *port,
 458                                struct sk_buff *skb)
 459 {
 460         const struct br_mrp_tlv_hdr *hdr;
 461         struct br_mrp_tlv_hdr _hdr;
 462
 463         /* Each MRP header starts with a version field which is 16 bits.
 464          * Therefore skip the version and get directly the TLV header.
 465          */
 466         hdr = skb_header_pointer(skb, sizeof(uint16_t), sizeof(_hdr), &_hdr);
 467         if (!hdr)
 468                 return;
 469
 470         if (hdr->type != BR_MRP_TLV_HEADER_RING_TEST)
 471                 return;
 472
 473         mrp->test_count_miss = 0;
 474
 475         /* Notify the userspace that the ring is closed only when the ring is
 476          * not closed
 477          */
 478         if (mrp->ring_state != BR_MRP_RING_STATE_CLOSED)
 479                 br_mrp_port_open(port->dev, false);
 480 }
 481
 482 /* This will just forward the frame to the other mrp ring port(MRC role) or will
 483  * not do anything.
 484  * note: already called with rcu_read_lock
 485  */
 486 static int br_mrp_rcv(struct net_bridge_port *p,
 487                       struct sk_buff *skb, struct net_device *dev)
 488 {
 489         struct net_device *s_dev, *p_dev, *d_dev;
 490         struct net_bridge_port *p_port, *s_port;
 491         struct net_bridge *br;
 492         struct sk_buff *nskb;
 493         struct br_mrp *mrp;
 494
 495         /* If port is disabled don't accept any frames */
 496         if (p->state == BR_STATE_DISABLED)
 497                 return 0;
 498
 499         br = p->br;
 500         mrp =  br_mrp_find_port(br, p);
 501         if (unlikely(!mrp))
 502                 return 0;
 503
 504         p_port = rcu_dereference(mrp->p_port);
 505         if (!p_port)
 506                 return 0;
 507
 508         s_port = rcu_dereference(mrp->s_port);
 509         if (!s_port)
 510                 return 0;
 511
 512         /* If the role is MRM then don't forward the frames */
 513         if (mrp->ring_role == BR_MRP_RING_ROLE_MRM) {
 514                 br_mrp_mrm_process(mrp, p, skb);
 515                 return 1;
 516         }
 517
 518         /* Clone the frame and forward it on the other MRP port */
 519         nskb = skb_clone(skb, GFP_ATOMIC);
 520         if (!nskb)
 521                 return 0;
 522
 523         p_dev = p_port->dev;
 524         s_dev = s_port->dev;
 525
 526         if (p_dev == dev)
 527                 d_dev = s_dev;
 528         else
 529                 d_dev = p_dev;
 530
 531         nskb->dev = d_dev;
 532         skb_push(nskb, ETH_HLEN);
 533         dev_queue_xmit(nskb);
 534
 535         return 1;
 536 }
 537
 538 /* Check if the frame was received on a port that is part of MRP ring
 539  * and if the frame has MRP eth. In that case process the frame otherwise do
 540  * normal forwarding.
 541  * note: already called with rcu_read_lock
 542  */
 543 int br_mrp_process(struct net_bridge_port *p, struct sk_buff *skb)
 544 {
 545         /* If there is no MRP instance do normal forwarding */
 546         if (likely(!(p->flags & BR_MRP_AWARE)))
 547                 goto out;
 548
 549         if (unlikely(skb->protocol == htons(ETH_P_MRP)))
 550                 return br_mrp_rcv(p, skb, p->dev);
 551
 552 out:
 553         return 0;
 554 }
 555
 556 bool br_mrp_enabled(struct net_bridge *br)
 557 {
 558         return !list_empty(&br->mrp_list);
 559 }