net/bridge/br_mrp_netlink.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2
   3 #include <net/genetlink.h>
   4
   5 #include <uapi/linux/mrp_bridge.h>
   6 #include "br_private.h"
   7 #include "br_private_mrp.h"
   8
   9 static const struct nla_policy br_mrp_policy[IFLA_BRIDGE_MRP_MAX + 1] = {
  10         [IFLA_BRIDGE_MRP_UNSPEC]        = { .type = NLA_REJECT },
  11         [IFLA_BRIDGE_MRP_INSTANCE]      = { .type = NLA_NESTED },
  12         [IFLA_BRIDGE_MRP_PORT_STATE]    = { .type = NLA_NESTED },
  13         [IFLA_BRIDGE_MRP_PORT_ROLE]     = { .type = NLA_NESTED },
  14         [IFLA_BRIDGE_MRP_RING_STATE]    = { .type = NLA_NESTED },
  15         [IFLA_BRIDGE_MRP_RING_ROLE]     = { .type = NLA_NESTED },
  16         [IFLA_BRIDGE_MRP_START_TEST]    = { .type = NLA_NESTED },
  17         [IFLA_BRIDGE_MRP_IN_ROLE]       = { .type = NLA_NESTED },
  18         [IFLA_BRIDGE_MRP_IN_STATE]      = { .type = NLA_NESTED },
  19         [IFLA_BRIDGE_MRP_START_IN_TEST] = { .type = NLA_NESTED },
  20 };
  21
  22 static const struct nla_policy
  23 br_mrp_instance_policy[IFLA_BRIDGE_MRP_INSTANCE_MAX + 1] = {
  24         [IFLA_BRIDGE_MRP_INSTANCE_UNSPEC]       = { .type = NLA_REJECT },
  25         [IFLA_BRIDGE_MRP_INSTANCE_RING_ID]      = { .type = NLA_U32 },
  26         [IFLA_BRIDGE_MRP_INSTANCE_P_IFINDEX]    = { .type = NLA_U32 },
  27         [IFLA_BRIDGE_MRP_INSTANCE_S_IFINDEX]    = { .type = NLA_U32 },
  28         [IFLA_BRIDGE_MRP_INSTANCE_PRIO]         = { .type = NLA_U16 },
  29 };
  30
  31 static int br_mrp_instance_parse(struct net_bridge *br, struct nlattr *attr,
  32                                  int cmd, struct netlink_ext_ack *extack)
  33 {
  34         struct nlattr *tb[IFLA_BRIDGE_MRP_INSTANCE_MAX + 1];
  35         struct br_mrp_instance inst;
  36         int err;
  37
  38         err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_INSTANCE_MAX, attr,
  39                                br_mrp_instance_policy, extack);
  40         if (err)
  41                 return err;
  42
  43         if (!tb[IFLA_BRIDGE_MRP_INSTANCE_RING_ID] ||
  44             !tb[IFLA_BRIDGE_MRP_INSTANCE_P_IFINDEX] ||
  45             !tb[IFLA_BRIDGE_MRP_INSTANCE_S_IFINDEX]) {
  46                 NL_SET_ERR_MSG_MOD(extack,
  47                                    "Missing attribute: RING_ID or P_IFINDEX or S_IFINDEX");
  48                 return -EINVAL;
  49         }
  50
  51         memset(&inst, 0, sizeof(inst));
  52
  53         inst.ring_id = nla_get_u32(tb[IFLA_BRIDGE_MRP_INSTANCE_RING_ID]);
  54         inst.p_ifindex = nla_get_u32(tb[IFLA_BRIDGE_MRP_INSTANCE_P_IFINDEX]);
  55         inst.s_ifindex = nla_get_u32(tb[IFLA_BRIDGE_MRP_INSTANCE_S_IFINDEX]);
  56         inst.prio = MRP_DEFAULT_PRIO;
  57
  58         if (tb[IFLA_BRIDGE_MRP_INSTANCE_PRIO])
  59                 inst.prio = nla_get_u16(tb[IFLA_BRIDGE_MRP_INSTANCE_PRIO]);
  60
  61         if (cmd == RTM_SETLINK)
  62                 return br_mrp_add(br, &inst);
  63         else
  64                 return br_mrp_del(br, &inst);
  65
  66         return 0;
  67 }
  68
  69 static const struct nla_policy
  70 br_mrp_port_state_policy[IFLA_BRIDGE_MRP_PORT_STATE_MAX + 1] = {
  71         [IFLA_BRIDGE_MRP_PORT_STATE_UNSPEC]     = { .type = NLA_REJECT },
  72         [IFLA_BRIDGE_MRP_PORT_STATE_STATE]      = { .type = NLA_U32 },
  73 };
  74
  75 static int br_mrp_port_state_parse(struct net_bridge_port *p,
  76                                    struct nlattr *attr,
  77                                    struct netlink_ext_ack *extack)
  78 {
  79         struct nlattr *tb[IFLA_BRIDGE_MRP_PORT_STATE_MAX + 1];
  80         enum br_mrp_port_state_type state;
  81         int err;
  82
  83         err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_PORT_STATE_MAX, attr,
  84                                br_mrp_port_state_policy, extack);
  85         if (err)
  86                 return err;
  87
  88         if (!tb[IFLA_BRIDGE_MRP_PORT_STATE_STATE]) {
  89                 NL_SET_ERR_MSG_MOD(extack, "Missing attribute: STATE");
  90                 return -EINVAL;
  91         }
  92
  93         state = nla_get_u32(tb[IFLA_BRIDGE_MRP_PORT_STATE_STATE]);
  94
  95         return br_mrp_set_port_state(p, state);
  96 }
  97
  98 static const struct nla_policy
  99 br_mrp_port_role_policy[IFLA_BRIDGE_MRP_PORT_ROLE_MAX + 1] = {
 100         [IFLA_BRIDGE_MRP_PORT_ROLE_UNSPEC]      = { .type = NLA_REJECT },
 101         [IFLA_BRIDGE_MRP_PORT_ROLE_ROLE]        = { .type = NLA_U32 },
 102 };
 103
 104 static int br_mrp_port_role_parse(struct net_bridge_port *p,
 105                                   struct nlattr *attr,
 106                                   struct netlink_ext_ack *extack)
 107 {
 108         struct nlattr *tb[IFLA_BRIDGE_MRP_PORT_ROLE_MAX + 1];
 109         enum br_mrp_port_role_type role;
 110         int err;
 111
 112         err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_PORT_ROLE_MAX, attr,
 113                                br_mrp_port_role_policy, extack);
 114         if (err)
 115                 return err;
 116
 117         if (!tb[IFLA_BRIDGE_MRP_PORT_ROLE_ROLE]) {
 118                 NL_SET_ERR_MSG_MOD(extack, "Missing attribute: ROLE");
 119                 return -EINVAL;
 120         }
 121
 122         role = nla_get_u32(tb[IFLA_BRIDGE_MRP_PORT_ROLE_ROLE]);
 123
 124         return br_mrp_set_port_role(p, role);
 125 }
 126
 127 static const struct nla_policy
 128 br_mrp_ring_state_policy[IFLA_BRIDGE_MRP_RING_STATE_MAX + 1] = {
 129         [IFLA_BRIDGE_MRP_RING_STATE_UNSPEC]     = { .type = NLA_REJECT },
 130         [IFLA_BRIDGE_MRP_RING_STATE_RING_ID]    = { .type = NLA_U32 },
 131         [IFLA_BRIDGE_MRP_RING_STATE_STATE]      = { .type = NLA_U32 },
 132 };
 133
 134 static int br_mrp_ring_state_parse(struct net_bridge *br, struct nlattr *attr,
 135                                    struct netlink_ext_ack *extack)
 136 {
 137         struct nlattr *tb[IFLA_BRIDGE_MRP_RING_STATE_MAX + 1];
 138         struct br_mrp_ring_state state;
 139         int err;
 140
 141         err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_RING_STATE_MAX, attr,
 142                                br_mrp_ring_state_policy, extack);
 143         if (err)
 144                 return err;
 145
 146         if (!tb[IFLA_BRIDGE_MRP_RING_STATE_RING_ID] ||
 147             !tb[IFLA_BRIDGE_MRP_RING_STATE_STATE]) {
 148                 NL_SET_ERR_MSG_MOD(extack,
 149                                    "Missing attribute: RING_ID or STATE");
 150                 return -EINVAL;
 151         }
 152
 153         memset(&state, 0x0, sizeof(state));
 154
 155         state.ring_id = nla_get_u32(tb[IFLA_BRIDGE_MRP_RING_STATE_RING_ID]);
 156         state.ring_state = nla_get_u32(tb[IFLA_BRIDGE_MRP_RING_STATE_STATE]);
 157
 158         return br_mrp_set_ring_state(br, &state);
 159 }
 160
 161 static const struct nla_policy
 162 br_mrp_ring_role_policy[IFLA_BRIDGE_MRP_RING_ROLE_MAX + 1] = {
 163         [IFLA_BRIDGE_MRP_RING_ROLE_UNSPEC]      = { .type = NLA_REJECT },
 164         [IFLA_BRIDGE_MRP_RING_ROLE_RING_ID]     = { .type = NLA_U32 },
 165         [IFLA_BRIDGE_MRP_RING_ROLE_ROLE]        = { .type = NLA_U32 },
 166 };
 167
 168 static int br_mrp_ring_role_parse(struct net_bridge *br, struct nlattr *attr,
 169                                   struct netlink_ext_ack *extack)
 170 {
 171         struct nlattr *tb[IFLA_BRIDGE_MRP_RING_ROLE_MAX + 1];
 172         struct br_mrp_ring_role role;
 173         int err;
 174
 175         err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_RING_ROLE_MAX, attr,
 176                                br_mrp_ring_role_policy, extack);
 177         if (err)
 178                 return err;
 179
 180         if (!tb[IFLA_BRIDGE_MRP_RING_ROLE_RING_ID] ||
 181             !tb[IFLA_BRIDGE_MRP_RING_ROLE_ROLE]) {
 182                 NL_SET_ERR_MSG_MOD(extack,
 183                                    "Missing attribute: RING_ID or ROLE");
 184                 return -EINVAL;
 185         }
 186
 187         memset(&role, 0x0, sizeof(role));
 188
 189         role.ring_id = nla_get_u32(tb[IFLA_BRIDGE_MRP_RING_ROLE_RING_ID]);
 190         role.ring_role = nla_get_u32(tb[IFLA_BRIDGE_MRP_RING_ROLE_ROLE]);
 191
 192         return br_mrp_set_ring_role(br, &role);
 193 }
 194
 195 static const struct nla_policy
 196 br_mrp_start_test_policy[IFLA_BRIDGE_MRP_START_TEST_MAX + 1] = {
 197         [IFLA_BRIDGE_MRP_START_TEST_UNSPEC]     = { .type = NLA_REJECT },
 198         [IFLA_BRIDGE_MRP_START_TEST_RING_ID]    = { .type = NLA_U32 },
 199         [IFLA_BRIDGE_MRP_START_TEST_INTERVAL]   = { .type = NLA_U32 },
 200         [IFLA_BRIDGE_MRP_START_TEST_MAX_MISS]   = { .type = NLA_U32 },
 201         [IFLA_BRIDGE_MRP_START_TEST_PERIOD]     = { .type = NLA_U32 },
 202         [IFLA_BRIDGE_MRP_START_TEST_MONITOR]    = { .type = NLA_U32 },
 203 };
 204
 205 static int br_mrp_start_test_parse(struct net_bridge *br, struct nlattr *attr,
 206                                    struct netlink_ext_ack *extack)
 207 {
 208         struct nlattr *tb[IFLA_BRIDGE_MRP_START_TEST_MAX + 1];
 209         struct br_mrp_start_test test;
 210         int err;
 211
 212         err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_START_TEST_MAX, attr,
 213                                br_mrp_start_test_policy, extack);
 214         if (err)
 215                 return err;
 216
 217         if (!tb[IFLA_BRIDGE_MRP_START_TEST_RING_ID] ||
 218             !tb[IFLA_BRIDGE_MRP_START_TEST_INTERVAL] ||
 219             !tb[IFLA_BRIDGE_MRP_START_TEST_MAX_MISS] ||
 220             !tb[IFLA_BRIDGE_MRP_START_TEST_PERIOD]) {
 221                 NL_SET_ERR_MSG_MOD(extack,
 222                                    "Missing attribute: RING_ID or INTERVAL or MAX_MISS or PERIOD");
 223                 return -EINVAL;
 224         }
 225
 226         memset(&test, 0x0, sizeof(test));
 227
 228         test.ring_id = nla_get_u32(tb[IFLA_BRIDGE_MRP_START_TEST_RING_ID]);
 229         test.interval = nla_get_u32(tb[IFLA_BRIDGE_MRP_START_TEST_INTERVAL]);
 230         test.max_miss = nla_get_u32(tb[IFLA_BRIDGE_MRP_START_TEST_MAX_MISS]);
 231         test.period = nla_get_u32(tb[IFLA_BRIDGE_MRP_START_TEST_PERIOD]);
 232         test.monitor = false;
 233
 234         if (tb[IFLA_BRIDGE_MRP_START_TEST_MONITOR])
 235                 test.monitor =
 236                         nla_get_u32(tb[IFLA_BRIDGE_MRP_START_TEST_MONITOR]);
 237
 238         return br_mrp_start_test(br, &test);
 239 }
 240
 241 static const struct nla_policy
 242 br_mrp_in_state_policy[IFLA_BRIDGE_MRP_IN_STATE_MAX + 1] = {
 243         [IFLA_BRIDGE_MRP_IN_STATE_UNSPEC]       = { .type = NLA_REJECT },
 244         [IFLA_BRIDGE_MRP_IN_STATE_IN_ID]        = { .type = NLA_U32 },
 245         [IFLA_BRIDGE_MRP_IN_STATE_STATE]        = { .type = NLA_U32 },
 246 };
 247
 248 static int br_mrp_in_state_parse(struct net_bridge *br, struct nlattr *attr,
 249                                  struct netlink_ext_ack *extack)
 250 {
 251         struct nlattr *tb[IFLA_BRIDGE_MRP_IN_STATE_MAX + 1];
 252         struct br_mrp_in_state state;
 253         int err;
 254
 255         err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_IN_STATE_MAX, attr,
 256                                br_mrp_in_state_policy, extack);
 257         if (err)
 258                 return err;
 259
 260         if (!tb[IFLA_BRIDGE_MRP_IN_STATE_IN_ID] ||
 261             !tb[IFLA_BRIDGE_MRP_IN_STATE_STATE]) {
 262                 NL_SET_ERR_MSG_MOD(extack,
 263                                    "Missing attribute: IN_ID or STATE");
 264                 return -EINVAL;
 265         }
 266
 267         memset(&state, 0x0, sizeof(state));
 268
 269         state.in_id = nla_get_u32(tb[IFLA_BRIDGE_MRP_IN_STATE_IN_ID]);
 270         state.in_state = nla_get_u32(tb[IFLA_BRIDGE_MRP_IN_STATE_STATE]);
 271
 272         return br_mrp_set_in_state(br, &state);
 273 }
 274
 275 static const struct nla_policy
 276 br_mrp_in_role_policy[IFLA_BRIDGE_MRP_IN_ROLE_MAX + 1] = {
 277         [IFLA_BRIDGE_MRP_IN_ROLE_UNSPEC]        = { .type = NLA_REJECT },
 278         [IFLA_BRIDGE_MRP_IN_ROLE_RING_ID]       = { .type = NLA_U32 },
 279         [IFLA_BRIDGE_MRP_IN_ROLE_IN_ID]         = { .type = NLA_U16 },
 280         [IFLA_BRIDGE_MRP_IN_ROLE_ROLE]          = { .type = NLA_U32 },
 281         [IFLA_BRIDGE_MRP_IN_ROLE_I_IFINDEX]     = { .type = NLA_U32 },
 282 };
 283
 284 static int br_mrp_in_role_parse(struct net_bridge *br, struct nlattr *attr,
 285                                 struct netlink_ext_ack *extack)
 286 {
 287         struct nlattr *tb[IFLA_BRIDGE_MRP_IN_ROLE_MAX + 1];
 288         struct br_mrp_in_role role;
 289         int err;
 290
 291         err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_IN_ROLE_MAX, attr,
 292                                br_mrp_in_role_policy, extack);
 293         if (err)
 294                 return err;
 295
 296         if (!tb[IFLA_BRIDGE_MRP_IN_ROLE_RING_ID] ||
 297             !tb[IFLA_BRIDGE_MRP_IN_ROLE_IN_ID] ||
 298             !tb[IFLA_BRIDGE_MRP_IN_ROLE_I_IFINDEX] ||
 299             !tb[IFLA_BRIDGE_MRP_IN_ROLE_ROLE]) {
 300                 NL_SET_ERR_MSG_MOD(extack,
 301                                    "Missing attribute: RING_ID or ROLE or IN_ID or I_IFINDEX");
 302                 return -EINVAL;
 303         }
 304
 305         memset(&role, 0x0, sizeof(role));
 306
 307         role.ring_id = nla_get_u32(tb[IFLA_BRIDGE_MRP_IN_ROLE_RING_ID]);
 308         role.in_id = nla_get_u16(tb[IFLA_BRIDGE_MRP_IN_ROLE_IN_ID]);
 309         role.i_ifindex = nla_get_u32(tb[IFLA_BRIDGE_MRP_IN_ROLE_I_IFINDEX]);
 310         role.in_role = nla_get_u32(tb[IFLA_BRIDGE_MRP_IN_ROLE_ROLE]);
 311
 312         return br_mrp_set_in_role(br, &role);
 313 }
 314
 315 static const struct nla_policy
 316 br_mrp_start_in_test_policy[IFLA_BRIDGE_MRP_START_IN_TEST_MAX + 1] = {
 317         [IFLA_BRIDGE_MRP_START_IN_TEST_UNSPEC]  = { .type = NLA_REJECT },
 318         [IFLA_BRIDGE_MRP_START_IN_TEST_IN_ID]   = { .type = NLA_U32 },
 319         [IFLA_BRIDGE_MRP_START_IN_TEST_INTERVAL]        = { .type = NLA_U32 },
 320         [IFLA_BRIDGE_MRP_START_IN_TEST_MAX_MISS]        = { .type = NLA_U32 },
 321         [IFLA_BRIDGE_MRP_START_IN_TEST_PERIOD]  = { .type = NLA_U32 },
 322 };
 323
 324 static int br_mrp_start_in_test_parse(struct net_bridge *br,
 325                                       struct nlattr *attr,
 326                                       struct netlink_ext_ack *extack)
 327 {
 328         struct nlattr *tb[IFLA_BRIDGE_MRP_START_IN_TEST_MAX + 1];
 329         struct br_mrp_start_in_test test;
 330         int err;
 331
 332         err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_START_IN_TEST_MAX, attr,
 333                                br_mrp_start_in_test_policy, extack);
 334         if (err)
 335                 return err;
 336
 337         if (!tb[IFLA_BRIDGE_MRP_START_IN_TEST_IN_ID] ||
 338             !tb[IFLA_BRIDGE_MRP_START_IN_TEST_INTERVAL] ||
 339             !tb[IFLA_BRIDGE_MRP_START_IN_TEST_MAX_MISS] ||
 340             !tb[IFLA_BRIDGE_MRP_START_IN_TEST_PERIOD]) {
 341                 NL_SET_ERR_MSG_MOD(extack,
 342                                    "Missing attribute: RING_ID or INTERVAL or MAX_MISS or PERIOD");
 343                 return -EINVAL;
 344         }
 345
 346         memset(&test, 0x0, sizeof(test));
 347
 348         test.in_id = nla_get_u32(tb[IFLA_BRIDGE_MRP_START_IN_TEST_IN_ID]);
 349         test.interval = nla_get_u32(tb[IFLA_BRIDGE_MRP_START_IN_TEST_INTERVAL]);
 350         test.max_miss = nla_get_u32(tb[IFLA_BRIDGE_MRP_START_IN_TEST_MAX_MISS]);
 351         test.period = nla_get_u32(tb[IFLA_BRIDGE_MRP_START_IN_TEST_PERIOD]);
 352
 353         return br_mrp_start_in_test(br, &test);
 354 }
 355
 356 int br_mrp_parse(struct net_bridge *br, struct net_bridge_port *p,
 357                  struct nlattr *attr, int cmd, struct netlink_ext_ack *extack)
 358 {
 359         struct nlattr *tb[IFLA_BRIDGE_MRP_MAX + 1];
 360         int err;
 361
 362         /* When this function is called for a port then the br pointer is
 363          * invalid, therefor set the br to point correctly
 364          */
 365         if (p)
 366                 br = p->br;
 367
 368         if (br->stp_enabled != BR_NO_STP) {
 369                 NL_SET_ERR_MSG_MOD(extack, "MRP can't be enabled if STP is already enabled");
 370                 return -EINVAL;
 371         }
 372
 373         err = nla_parse_nested(tb, IFLA_BRIDGE_MRP_MAX, attr,
 374                                br_mrp_policy, extack);
 375         if (err)
 376                 return err;
 377
 378         if (tb[IFLA_BRIDGE_MRP_INSTANCE]) {
 379                 err = br_mrp_instance_parse(br, tb[IFLA_BRIDGE_MRP_INSTANCE],
 380                                             cmd, extack);
 381                 if (err)
 382                         return err;
 383         }
 384
 385         if (tb[IFLA_BRIDGE_MRP_PORT_STATE]) {
 386                 err = br_mrp_port_state_parse(p, tb[IFLA_BRIDGE_MRP_PORT_STATE],
 387                                               extack);
 388                 if (err)
 389                         return err;
 390         }
 391
 392         if (tb[IFLA_BRIDGE_MRP_PORT_ROLE]) {
 393                 err = br_mrp_port_role_parse(p, tb[IFLA_BRIDGE_MRP_PORT_ROLE],
 394                                              extack);
 395                 if (err)
 396                         return err;
 397         }
 398
 399         if (tb[IFLA_BRIDGE_MRP_RING_STATE]) {
 400                 err = br_mrp_ring_state_parse(br,
 401                                               tb[IFLA_BRIDGE_MRP_RING_STATE],
 402                                               extack);
 403                 if (err)
 404                         return err;
 405         }
 406
 407         if (tb[IFLA_BRIDGE_MRP_RING_ROLE]) {
 408                 err = br_mrp_ring_role_parse(br, tb[IFLA_BRIDGE_MRP_RING_ROLE],
 409                                              extack);
 410                 if (err)
 411                         return err;
 412         }
 413
 414         if (tb[IFLA_BRIDGE_MRP_START_TEST]) {
 415                 err = br_mrp_start_test_parse(br,
 416                                               tb[IFLA_BRIDGE_MRP_START_TEST],
 417                                               extack);
 418                 if (err)
 419                         return err;
 420         }
 421
 422         if (tb[IFLA_BRIDGE_MRP_IN_STATE]) {
 423                 err = br_mrp_in_state_parse(br, tb[IFLA_BRIDGE_MRP_IN_STATE],
 424                                             extack);
 425                 if (err)
 426                         return err;
 427         }
 428
 429         if (tb[IFLA_BRIDGE_MRP_IN_ROLE]) {
 430                 err = br_mrp_in_role_parse(br, tb[IFLA_BRIDGE_MRP_IN_ROLE],
 431                                            extack);
 432                 if (err)
 433                         return err;
 434         }
 435
 436         if (tb[IFLA_BRIDGE_MRP_START_IN_TEST]) {
 437                 err = br_mrp_start_in_test_parse(br,
 438                                                  tb[IFLA_BRIDGE_MRP_START_IN_TEST],
 439                                                  extack);
 440                 if (err)
 441                         return err;
 442         }
 443
 444         return 0;
 445 }
 446
 447 int br_mrp_fill_info(struct sk_buff *skb, struct net_bridge *br)
 448 {
 449         struct nlattr *tb, *mrp_tb;
 450         struct br_mrp *mrp;
 451
 452         mrp_tb = nla_nest_start_noflag(skb, IFLA_BRIDGE_MRP);
 453         if (!mrp_tb)
 454                 return -EMSGSIZE;
 455
 456         hlist_for_each_entry_rcu(mrp, &br->mrp_list, list) {
 457                 struct net_bridge_port *p;
 458
 459                 tb = nla_nest_start_noflag(skb, IFLA_BRIDGE_MRP_INFO);
 460                 if (!tb)
 461                         goto nla_info_failure;
 462
 463                 if (nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_RING_ID,
 464                                 mrp->ring_id))
 465                         goto nla_put_failure;
 466
 467                 p = rcu_dereference(mrp->p_port);
 468                 if (p && nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_P_IFINDEX,
 469                                      p->dev->ifindex))
 470                         goto nla_put_failure;
 471
 472                 p = rcu_dereference(mrp->s_port);
 473                 if (p && nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_S_IFINDEX,
 474                                      p->dev->ifindex))
 475                         goto nla_put_failure;
 476
 477                 p = rcu_dereference(mrp->i_port);
 478                 if (p && nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_I_IFINDEX,
 479                                      p->dev->ifindex))
 480                         goto nla_put_failure;
 481
 482                 if (nla_put_u16(skb, IFLA_BRIDGE_MRP_INFO_PRIO,
 483                                 mrp->prio))
 484                         goto nla_put_failure;
 485                 if (nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_RING_STATE,
 486                                 mrp->ring_state))
 487                         goto nla_put_failure;
 488                 if (nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_RING_ROLE,
 489                                 mrp->ring_role))
 490                         goto nla_put_failure;
 491                 if (nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_TEST_INTERVAL,
 492                                 mrp->test_interval))
 493                         goto nla_put_failure;
 494                 if (nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_TEST_MAX_MISS,
 495                                 mrp->test_max_miss))
 496                         goto nla_put_failure;
 497                 if (nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_TEST_MONITOR,
 498                                 mrp->test_monitor))
 499                         goto nla_put_failure;
 500
 501                 if (nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_IN_STATE,
 502                                 mrp->in_state))
 503                         goto nla_put_failure;
 504                 if (nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_IN_ROLE,
 505                                 mrp->in_role))
 506                         goto nla_put_failure;
 507                 if (nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_IN_TEST_INTERVAL,
 508                                 mrp->in_test_interval))
 509                         goto nla_put_failure;
 510                 if (nla_put_u32(skb, IFLA_BRIDGE_MRP_INFO_IN_TEST_MAX_MISS,
 511                                 mrp->in_test_max_miss))
 512                         goto nla_put_failure;
 513
 514                 nla_nest_end(skb, tb);
 515         }
 516         nla_nest_end(skb, mrp_tb);
 517
 518         return 0;
 519
 520 nla_put_failure:
 521         nla_nest_cancel(skb, tb);
 522
 523 nla_info_failure:
 524         nla_nest_cancel(skb, mrp_tb);
 525
 526         return -EMSGSIZE;
 527 }
 528
 529 int br_mrp_ring_port_open(struct net_device *dev, u8 loc)
 530 {
 531         struct net_bridge_port *p;
 532         int err = 0;
 533
 534         p = br_port_get_rcu(dev);
 535         if (!p) {
 536                 err = -EINVAL;
 537                 goto out;
 538         }
 539
 540         if (loc)
 541                 p->flags |= BR_MRP_LOST_CONT;
 542         else
 543                 p->flags &= ~BR_MRP_LOST_CONT;
 544
 545         br_ifinfo_notify(RTM_NEWLINK, NULL, p);
 546
 547 out:
 548         return err;
 549 }
 550
 551 int br_mrp_in_port_open(struct net_device *dev, u8 loc)
 552 {
 553         struct net_bridge_port *p;
 554         int err = 0;
 555
 556         p = br_port_get_rcu(dev);
 557         if (!p) {
 558                 err = -EINVAL;
 559                 goto out;
 560         }
 561
 562         if (loc)
 563                 p->flags |= BR_MRP_LOST_IN_CONT;
 564         else
 565                 p->flags &= ~BR_MRP_LOST_IN_CONT;
 566
 567         br_ifinfo_notify(RTM_NEWLINK, NULL, p);
 568
 569 out:
 570         return err;
 571 }