bridge.c

   1 /*
   2  * netifd - network interface daemon
   3  * Copyright (C) 2012 Felix Fietkau <nbd@openwrt.org>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License version 2
   7  * as published by the Free Software Foundation
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  */
  14 #include <string.h>
  15 #include <stdlib.h>
  16 #include <stdio.h>
  17 #include <assert.h>
  18 #include <errno.h>
  19
  20 #include "netifd.h"
  21 #include "device.h"
  22 #include "interface.h"
  23 #include "system.h"
  24
  25 enum {
  26         BRIDGE_ATTR_IFNAME,
  27         BRIDGE_ATTR_STP,
  28         BRIDGE_ATTR_FORWARD_DELAY,
  29         BRIDGE_ATTR_PRIORITY,
  30         BRIDGE_ATTR_IGMP_SNOOP,
  31         BRIDGE_ATTR_AGEING_TIME,
  32         BRIDGE_ATTR_HELLO_TIME,
  33         BRIDGE_ATTR_MAX_AGE,
  34         BRIDGE_ATTR_BRIDGE_EMPTY,
  35         BRIDGE_ATTR_MULTICAST_QUERIER,
  36         __BRIDGE_ATTR_MAX
  37 };
  38
  39 static const struct blobmsg_policy bridge_attrs[__BRIDGE_ATTR_MAX] = {
  40         [BRIDGE_ATTR_IFNAME] = { "ifname", BLOBMSG_TYPE_ARRAY },
  41         [BRIDGE_ATTR_STP] = { "stp", BLOBMSG_TYPE_BOOL },
  42         [BRIDGE_ATTR_FORWARD_DELAY] = { "forward_delay", BLOBMSG_TYPE_INT32 },
  43         [BRIDGE_ATTR_PRIORITY] = { "priority", BLOBMSG_TYPE_INT32 },
  44         [BRIDGE_ATTR_AGEING_TIME] = { "ageing_time", BLOBMSG_TYPE_INT32 },
  45         [BRIDGE_ATTR_HELLO_TIME] = { "hello_time", BLOBMSG_TYPE_INT32 },
  46         [BRIDGE_ATTR_MAX_AGE] = { "max_age", BLOBMSG_TYPE_INT32 },
  47         [BRIDGE_ATTR_IGMP_SNOOP] = { "igmp_snooping", BLOBMSG_TYPE_BOOL },
  48         [BRIDGE_ATTR_BRIDGE_EMPTY] = { "bridge_empty", BLOBMSG_TYPE_BOOL },
  49         [BRIDGE_ATTR_MULTICAST_QUERIER] = { "multicast_querier", BLOBMSG_TYPE_BOOL },
  50 };
  51
  52 static const struct uci_blob_param_info bridge_attr_info[__BRIDGE_ATTR_MAX] = {
  53         [BRIDGE_ATTR_IFNAME] = { .type = BLOBMSG_TYPE_STRING },
  54 };
  55
  56 static const struct uci_blob_param_list bridge_attr_list = {
  57         .n_params = __BRIDGE_ATTR_MAX,
  58         .params = bridge_attrs,
  59         .info = bridge_attr_info,
  60
  61         .n_next = 1,
  62         .next = { &device_attr_list },
  63 };
  64
  65 static struct device *bridge_create(const char *name, struct blob_attr *attr);
  66 static void bridge_config_init(struct device *dev);
  67 static void bridge_free(struct device *dev);
  68 static void bridge_dump_info(struct device *dev, struct blob_buf *b);
  69 enum dev_change_type
  70 bridge_reload(struct device *dev, struct blob_attr *attr);
  71
  72 const struct device_type bridge_device_type = {
  73         .name = "Bridge",
  74         .config_params = &bridge_attr_list,
  75
  76         .create = bridge_create,
  77         .config_init = bridge_config_init,
  78         .reload = bridge_reload,
  79         .free = bridge_free,
  80         .dump_info = bridge_dump_info,
  81 };
  82
  83 struct bridge_state {
  84         struct device dev;
  85         device_state_cb set_state;
  86
  87         struct blob_attr *config_data;
  88         struct bridge_config config;
  89         struct blob_attr *ifnames;
  90         bool active;
  91         bool force_active;
  92
  93         struct uloop_timeout retry;
  94         struct bridge_member *primary_port;
  95         struct vlist_tree members;
  96         int n_present;
  97         int n_failed;
  98 };
  99
 100 struct bridge_member {
 101         struct vlist_node node;
 102         struct bridge_state *bst;
 103         struct device_user dev;
 104         bool present;
 105         char name[];
 106 };
 107
 108 static void
 109 bridge_reset_primary(struct bridge_state *bst)
 110 {
 111         struct bridge_member *bm;
 112
 113         if (!bst->primary_port &&
 114             (bst->dev.settings.flags & DEV_OPT_MACADDR))
 115                 return;
 116
 117         bst->primary_port = NULL;
 118         bst->dev.settings.flags &= ~DEV_OPT_MACADDR;
 119         vlist_for_each_element(&bst->members, bm, node) {
 120                 uint8_t *macaddr;
 121
 122                 if (!bm->present)
 123                         continue;
 124
 125                 bst->primary_port = bm;
 126                 if (bm->dev.dev->settings.flags & DEV_OPT_MACADDR)
 127                         macaddr = bm->dev.dev->settings.macaddr;
 128                 else
 129                         macaddr = bm->dev.dev->orig_settings.macaddr;
 130                 memcpy(bst->dev.settings.macaddr, macaddr, 6);
 131                 bst->dev.settings.flags |= DEV_OPT_MACADDR;
 132                 return;
 133         }
 134 }
 135
 136 static int
 137 bridge_disable_member(struct bridge_member *bm)
 138 {
 139         struct bridge_state *bst = bm->bst;
 140
 141         if (!bm->present)
 142                 return 0;
 143
 144         system_bridge_delif(&bst->dev, bm->dev.dev);
 145         device_release(&bm->dev);
 146
 147         device_broadcast_event(&bst->dev, DEV_EVENT_TOPO_CHANGE);
 148
 149         return 0;
 150 }
 151
 152 static int
 153 bridge_enable_interface(struct bridge_state *bst)
 154 {
 155         int ret;
 156
 157         if (bst->active)
 158                 return 0;
 159
 160         ret = system_bridge_addbr(&bst->dev, &bst->config);
 161         if (ret < 0)
 162                 return ret;
 163
 164         bst->active = true;
 165         return 0;
 166 }
 167
 168 static void
 169 bridge_disable_interface(struct bridge_state *bst)
 170 {
 171         if (!bst->active)
 172                 return;
 173
 174         system_bridge_delbr(&bst->dev);
 175         bst->active = false;
 176 }
 177
 178 static int
 179 bridge_enable_member(struct bridge_member *bm)
 180 {
 181         struct bridge_state *bst = bm->bst;
 182         int ret;
 183
 184         if (!bm->present)
 185                 return 0;
 186
 187         ret = bridge_enable_interface(bst);
 188         if (ret)
 189                 goto error;
 190
 191         /* Disable IPv6 for bridge members */
 192         if (!(bm->dev.dev->settings.flags & DEV_OPT_IPV6)) {
 193                 bm->dev.dev->settings.ipv6 = 0;
 194                 bm->dev.dev->settings.flags |= DEV_OPT_IPV6;
 195         }
 196
 197         ret = device_claim(&bm->dev);
 198         if (ret < 0)
 199                 goto error;
 200
 201         ret = system_bridge_addif(&bst->dev, bm->dev.dev);
 202         if (ret < 0) {
 203                 D(DEVICE, "Bridge device %s could not be added\n", bm->dev.dev->ifname);
 204                 goto error;
 205         }
 206
 207         device_set_present(&bst->dev, true);
 208         device_broadcast_event(&bst->dev, DEV_EVENT_TOPO_CHANGE);
 209
 210         return 0;
 211
 212 error:
 213         bst->n_failed++;
 214         bm->present = false;
 215         bst->n_present--;
 216         device_release(&bm->dev);
 217
 218         return ret;
 219 }
 220
 221 static void
 222 bridge_remove_member(struct bridge_member *bm)
 223 {
 224         struct bridge_state *bst = bm->bst;
 225
 226         if (!bm->present)
 227                 return;
 228
 229         if (bm == bst->primary_port)
 230                 bridge_reset_primary(bst);
 231
 232         if (bst->dev.active)
 233                 bridge_disable_member(bm);
 234
 235         bm->present = false;
 236         bm->bst->n_present--;
 237
 238         if (bst->config.bridge_empty)
 239                 return;
 240
 241         bst->force_active = false;
 242         if (bst->n_present == 0)
 243                 device_set_present(&bst->dev, false);
 244 }
 245
 246 static void
 247 bridge_free_member(struct bridge_member *bm)
 248 {
 249         struct device *dev = bm->dev.dev;
 250
 251         bridge_remove_member(bm);
 252         device_remove_user(&bm->dev);
 253
 254         /*
 255          * When reloading the config and moving a device from one bridge to
 256          * another, the other bridge may have tried to claim this device
 257          * before it was removed here.
 258          * Ensure that claiming the device is retried by toggling its present
 259          * state
 260          */
 261         if (dev->present) {
 262                 device_set_present(dev, false);
 263                 device_set_present(dev, true);
 264         }
 265
 266         free(bm);
 267 }
 268
 269 static void
 270 bridge_check_retry(struct bridge_state *bst)
 271 {
 272         if (!bst->n_failed)
 273                 return;
 274
 275         uloop_timeout_set(&bst->retry, 100);
 276 }
 277
 278 static void
 279 bridge_member_cb(struct device_user *dev, enum device_event ev)
 280 {
 281         struct bridge_member *bm = container_of(dev, struct bridge_member, dev);
 282         struct bridge_state *bst = bm->bst;
 283
 284         switch (ev) {
 285         case DEV_EVENT_ADD:
 286                 assert(!bm->present);
 287
 288                 bm->present = true;
 289                 bst->n_present++;
 290
 291                 if (bst->n_present == 1)
 292                         device_set_present(&bst->dev, true);
 293                 if (bst->dev.active && !bridge_enable_member(bm)) {
 294                         /*
 295                          * Adding a bridge member can overwrite the bridge mtu
 296                          * in the kernel, apply the bridge settings in case the
 297                          * bridge mtu is set
 298                          */
 299                         system_if_apply_settings(&bst->dev, &bst->dev.settings,
 300                                                  DEV_OPT_MTU);
 301                 }
 302
 303                 break;
 304         case DEV_EVENT_REMOVE:
 305                 if (dev->hotplug) {
 306                         vlist_delete(&bst->members, &bm->node);
 307                         return;
 308                 }
 309
 310                 if (bm->present)
 311                         bridge_remove_member(bm);
 312
 313                 break;
 314         default:
 315                 return;
 316         }
 317 }
 318
 319 static int
 320 bridge_set_down(struct bridge_state *bst)
 321 {
 322         struct bridge_member *bm;
 323
 324         bst->set_state(&bst->dev, false);
 325
 326         vlist_for_each_element(&bst->members, bm, node)
 327                 bridge_disable_member(bm);
 328
 329         bridge_disable_interface(bst);
 330
 331         return 0;
 332 }
 333
 334 static int
 335 bridge_set_up(struct bridge_state *bst)
 336 {
 337         struct bridge_member *bm;
 338         int ret;
 339
 340         if (!bst->n_present) {
 341                 if (!bst->force_active)
 342                         return -ENOENT;
 343
 344                 ret = bridge_enable_interface(bst);
 345                 if (ret)
 346                         return ret;
 347         }
 348
 349         bst->n_failed = 0;
 350         vlist_for_each_element(&bst->members, bm, node)
 351                 bridge_enable_member(bm);
 352         bridge_check_retry(bst);
 353
 354         if (!bst->force_active && !bst->n_present) {
 355                 /* initialization of all member interfaces failed */
 356                 bridge_disable_interface(bst);
 357                 device_set_present(&bst->dev, false);
 358                 return -ENOENT;
 359         }
 360
 361         bridge_reset_primary(bst);
 362         ret = bst->set_state(&bst->dev, true);
 363         if (ret < 0)
 364                 bridge_set_down(bst);
 365
 366         return ret;
 367 }
 368
 369 static int
 370 bridge_set_state(struct device *dev, bool up)
 371 {
 372         struct bridge_state *bst;
 373
 374         bst = container_of(dev, struct bridge_state, dev);
 375
 376         if (up)
 377                 return bridge_set_up(bst);
 378         else
 379                 return bridge_set_down(bst);
 380 }
 381
 382 static struct bridge_member *
 383 bridge_create_member(struct bridge_state *bst, struct device *dev, bool hotplug)
 384 {
 385         struct bridge_member *bm;
 386
 387         bm = calloc(1, sizeof(*bm) + strlen(dev->ifname) + 1);
 388         if (!bm)
 389                 return NULL;
 390
 391         bm->bst = bst;
 392         bm->dev.cb = bridge_member_cb;
 393         bm->dev.hotplug = hotplug;
 394         strcpy(bm->name, dev->ifname);
 395         bm->dev.dev = dev;
 396         vlist_add(&bst->members, &bm->node, bm->name);
 397         // Need to look up the bridge member again as the above
 398         // created pointer will be freed in case the bridge member
 399         // already existed
 400         bm = vlist_find(&bst->members, dev->ifname, bm, node);
 401         if (hotplug && bm)
 402                 bm->node.version = -1;
 403
 404         return bm;
 405 }
 406
 407 static void
 408 bridge_member_update(struct vlist_tree *tree, struct vlist_node *node_new,
 409                      struct vlist_node *node_old)
 410 {
 411         struct bridge_member *bm;
 412         struct device *dev;
 413
 414         if (node_new) {
 415                 bm = container_of(node_new, struct bridge_member, node);
 416
 417                 if (node_old) {
 418                         free(bm);
 419                         return;
 420                 }
 421
 422                 dev = bm->dev.dev;
 423                 bm->dev.dev = NULL;
 424                 device_add_user(&bm->dev, dev);
 425         }
 426
 427
 428         if (node_old) {
 429                 bm = container_of(node_old, struct bridge_member, node);
 430                 bridge_free_member(bm);
 431         }
 432 }
 433
 434
 435 static void
 436 bridge_add_member(struct bridge_state *bst, const char *name)
 437 {
 438         struct device *dev;
 439
 440         dev = device_get(name, true);
 441         if (!dev)
 442                 return;
 443
 444         bridge_create_member(bst, dev, false);
 445 }
 446
 447 static int
 448 bridge_hotplug_add(struct device *dev, struct device *member)
 449 {
 450         struct bridge_state *bst = container_of(dev, struct bridge_state, dev);
 451
 452         bridge_create_member(bst, member, true);
 453
 454         return 0;
 455 }
 456
 457 static int
 458 bridge_hotplug_del(struct device *dev, struct device *member)
 459 {
 460         struct bridge_state *bst = container_of(dev, struct bridge_state, dev);
 461         struct bridge_member *bm;
 462
 463         bm = vlist_find(&bst->members, member->ifname, bm, node);
 464         if (!bm)
 465                 return UBUS_STATUS_NOT_FOUND;
 466
 467         vlist_delete(&bst->members, &bm->node);
 468         return 0;
 469 }
 470
 471 static int
 472 bridge_hotplug_prepare(struct device *dev)
 473 {
 474         struct bridge_state *bst;
 475
 476         bst = container_of(dev, struct bridge_state, dev);
 477         bst->force_active = true;
 478         device_set_present(&bst->dev, true);
 479
 480         return 0;
 481 }
 482
 483 static const struct device_hotplug_ops bridge_ops = {
 484         .prepare = bridge_hotplug_prepare,
 485         .add = bridge_hotplug_add,
 486         .del = bridge_hotplug_del
 487 };
 488
 489 static void
 490 bridge_free(struct device *dev)
 491 {
 492         struct bridge_state *bst;
 493
 494         bst = container_of(dev, struct bridge_state, dev);
 495         vlist_flush_all(&bst->members);
 496         free(bst->config_data);
 497         free(bst);
 498 }
 499
 500 static void
 501 bridge_dump_info(struct device *dev, struct blob_buf *b)
 502 {
 503         struct bridge_state *bst;
 504         struct bridge_member *bm;
 505         void *list;
 506
 507         bst = container_of(dev, struct bridge_state, dev);
 508
 509         system_if_dump_info(dev, b);
 510         list = blobmsg_open_array(b, "bridge-members");
 511
 512         vlist_for_each_element(&bst->members, bm, node)
 513                 blobmsg_add_string(b, NULL, bm->dev.dev->ifname);
 514
 515         blobmsg_close_array(b, list);
 516 }
 517
 518 static void
 519 bridge_config_init(struct device *dev)
 520 {
 521         struct bridge_state *bst;
 522         struct blob_attr *cur;
 523         int rem;
 524
 525         bst = container_of(dev, struct bridge_state, dev);
 526
 527         if (bst->config.bridge_empty) {
 528                 bst->force_active = true;
 529                 device_set_present(&bst->dev, true);
 530         }
 531
 532         bst->n_failed = 0;
 533         vlist_update(&bst->members);
 534         if (bst->ifnames) {
 535                 blobmsg_for_each_attr(cur, bst->ifnames, rem) {
 536                         bridge_add_member(bst, blobmsg_data(cur));
 537                 }
 538         }
 539         vlist_flush(&bst->members);
 540         bridge_check_retry(bst);
 541 }
 542
 543 static void
 544 bridge_apply_settings(struct bridge_state *bst, struct blob_attr **tb)
 545 {
 546         struct bridge_config *cfg = &bst->config;
 547         struct blob_attr *cur;
 548
 549         /* defaults */
 550         cfg->stp = false;
 551         cfg->forward_delay = 2;
 552         cfg->igmp_snoop = true;
 553         cfg->multicast_querier = true;
 554         cfg->bridge_empty = false;
 555         cfg->priority = 0x7FFF;
 556
 557         if ((cur = tb[BRIDGE_ATTR_STP]))
 558                 cfg->stp = blobmsg_get_bool(cur);
 559
 560         if ((cur = tb[BRIDGE_ATTR_FORWARD_DELAY]))
 561                 cfg->forward_delay = blobmsg_get_u32(cur);
 562
 563         if ((cur = tb[BRIDGE_ATTR_PRIORITY]))
 564                 cfg->priority = blobmsg_get_u32(cur);
 565
 566         if ((cur = tb[BRIDGE_ATTR_IGMP_SNOOP]))
 567                 cfg->multicast_querier = cfg->igmp_snoop = blobmsg_get_bool(cur);
 568
 569         if ((cur = tb[BRIDGE_ATTR_MULTICAST_QUERIER]))
 570                 cfg->multicast_querier = blobmsg_get_bool(cur);
 571
 572         if ((cur = tb[BRIDGE_ATTR_AGEING_TIME])) {
 573                 cfg->ageing_time = blobmsg_get_u32(cur);
 574                 cfg->flags |= BRIDGE_OPT_AGEING_TIME;
 575         }
 576
 577         if ((cur = tb[BRIDGE_ATTR_HELLO_TIME])) {
 578                 cfg->hello_time = blobmsg_get_u32(cur);
 579                 cfg->flags |= BRIDGE_OPT_HELLO_TIME;
 580         }
 581
 582         if ((cur = tb[BRIDGE_ATTR_MAX_AGE])) {
 583                 cfg->max_age = blobmsg_get_u32(cur);
 584                 cfg->flags |= BRIDGE_OPT_MAX_AGE;
 585         }
 586
 587         if ((cur = tb[BRIDGE_ATTR_BRIDGE_EMPTY]))
 588                 cfg->bridge_empty = blobmsg_get_bool(cur);
 589 }
 590
 591 enum dev_change_type
 592 bridge_reload(struct device *dev, struct blob_attr *attr)
 593 {
 594         struct blob_attr *tb_dev[__DEV_ATTR_MAX];
 595         struct blob_attr *tb_br[__BRIDGE_ATTR_MAX];
 596         enum dev_change_type ret = DEV_CONFIG_APPLIED;
 597         unsigned long diff;
 598         struct bridge_state *bst;
 599
 600         BUILD_BUG_ON(sizeof(diff) < __BRIDGE_ATTR_MAX / 8);
 601         BUILD_BUG_ON(sizeof(diff) < __DEV_ATTR_MAX / 8);
 602
 603         bst = container_of(dev, struct bridge_state, dev);
 604         attr = blob_memdup(attr);
 605
 606         blobmsg_parse(device_attr_list.params, __DEV_ATTR_MAX, tb_dev,
 607                 blob_data(attr), blob_len(attr));
 608         blobmsg_parse(bridge_attrs, __BRIDGE_ATTR_MAX, tb_br,
 609                 blob_data(attr), blob_len(attr));
 610
 611         bst->ifnames = tb_br[BRIDGE_ATTR_IFNAME];
 612         device_init_settings(dev, tb_dev);
 613         bridge_apply_settings(bst, tb_br);
 614
 615         if (bst->config_data) {
 616                 struct blob_attr *otb_dev[__DEV_ATTR_MAX];
 617                 struct blob_attr *otb_br[__BRIDGE_ATTR_MAX];
 618
 619                 blobmsg_parse(device_attr_list.params, __DEV_ATTR_MAX, otb_dev,
 620                         blob_data(bst->config_data), blob_len(bst->config_data));
 621
 622                 diff = 0;
 623                 uci_blob_diff(tb_dev, otb_dev, &device_attr_list, &diff);
 624                 if (diff)
 625                     ret = DEV_CONFIG_RESTART;
 626
 627                 blobmsg_parse(bridge_attrs, __BRIDGE_ATTR_MAX, otb_br,
 628                         blob_data(bst->config_data), blob_len(bst->config_data));
 629
 630                 diff = 0;
 631                 uci_blob_diff(tb_br, otb_br, &bridge_attr_list, &diff);
 632                 if (diff & ~(1 << BRIDGE_ATTR_IFNAME))
 633                     ret = DEV_CONFIG_RESTART;
 634
 635                 bridge_config_init(dev);
 636         }
 637
 638         free(bst->config_data);
 639         bst->config_data = attr;
 640         return ret;
 641 }
 642
 643 static void
 644 bridge_retry_members(struct uloop_timeout *timeout)
 645 {
 646         struct bridge_state *bst = container_of(timeout, struct bridge_state, retry);
 647         struct bridge_member *bm;
 648
 649         bst->n_failed = 0;
 650         vlist_for_each_element(&bst->members, bm, node) {
 651                 if (bm->present)
 652                         continue;
 653
 654                 if (!bm->dev.dev->present)
 655                         continue;
 656
 657                 bm->present = true;
 658                 bst->n_present++;
 659                 bridge_enable_member(bm);
 660         }
 661 }
 662
 663 static struct device *
 664 bridge_create(const char *name, struct blob_attr *attr)
 665 {
 666         struct bridge_state *bst;
 667         struct device *dev = NULL;
 668
 669         bst = calloc(1, sizeof(*bst));
 670         if (!bst)
 671                 return NULL;
 672
 673         dev = &bst->dev;
 674         device_init(dev, &bridge_device_type, name);
 675         dev->config_pending = true;
 676         bst->retry.cb = bridge_retry_members;
 677
 678         bst->set_state = dev->set_state;
 679         dev->set_state = bridge_set_state;
 680
 681         dev->hotplug_ops = &bridge_ops;
 682
 683         vlist_init(&bst->members, avl_strcmp, bridge_member_update);
 684         bst->members.keep_old = true;
 685         bridge_reload(dev, attr);
 686
 687         return dev;
 688 }