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_MAX
  36 };
  37
  38 static const struct blobmsg_policy bridge_attrs[__BRIDGE_ATTR_MAX] = {
  39         [BRIDGE_ATTR_IFNAME] = { "ifname", BLOBMSG_TYPE_ARRAY },
  40         [BRIDGE_ATTR_STP] = { "stp", BLOBMSG_TYPE_BOOL },
  41         [BRIDGE_ATTR_FORWARD_DELAY] = { "forward_delay", BLOBMSG_TYPE_INT32 },
  42         [BRIDGE_ATTR_PRIORITY] = { "priority", BLOBMSG_TYPE_INT32 },
  43         [BRIDGE_ATTR_AGEING_TIME] = { "ageing_time", BLOBMSG_TYPE_INT32 },
  44         [BRIDGE_ATTR_HELLO_TIME] = { "hello_time", BLOBMSG_TYPE_INT32 },
  45         [BRIDGE_ATTR_MAX_AGE] = { "max_age", BLOBMSG_TYPE_INT32 },
  46         [BRIDGE_ATTR_IGMP_SNOOP] = { "igmp_snooping", BLOBMSG_TYPE_BOOL },
  47         [BRIDGE_ATTR_BRIDGE_EMPTY] = { "bridge_empty", BLOBMSG_TYPE_BOOL },
  48 };
  49
  50 static const struct uci_blob_param_info bridge_attr_info[__BRIDGE_ATTR_MAX] = {
  51         [BRIDGE_ATTR_IFNAME] = { .type = BLOBMSG_TYPE_STRING },
  52 };
  53
  54 static const struct uci_blob_param_list bridge_attr_list = {
  55         .n_params = __BRIDGE_ATTR_MAX,
  56         .params = bridge_attrs,
  57         .info = bridge_attr_info,
  58
  59         .n_next = 1,
  60         .next = { &device_attr_list },
  61 };
  62
  63 static struct device *bridge_create(const char *name, struct blob_attr *attr);
  64 static void bridge_config_init(struct device *dev);
  65 static void bridge_free(struct device *dev);
  66 static void bridge_dump_info(struct device *dev, struct blob_buf *b);
  67 enum dev_change_type
  68 bridge_reload(struct device *dev, struct blob_attr *attr);
  69
  70 const struct device_type bridge_device_type = {
  71         .name = "Bridge",
  72         .config_params = &bridge_attr_list,
  73
  74         .create = bridge_create,
  75         .config_init = bridge_config_init,
  76         .reload = bridge_reload,
  77         .free = bridge_free,
  78         .dump_info = bridge_dump_info,
  79 };
  80
  81 struct bridge_state {
  82         struct device dev;
  83         device_state_cb set_state;
  84
  85         struct blob_attr *config_data;
  86         struct bridge_config config;
  87         struct blob_attr *ifnames;
  88         bool active;
  89         bool force_active;
  90
  91         struct bridge_member *primary_port;
  92         struct vlist_tree members;
  93         int n_present;
  94 };
  95
  96 struct bridge_member {
  97         struct vlist_node node;
  98         struct bridge_state *bst;
  99         struct device_user dev;
 100         bool present;
 101         char name[];
 102 };
 103
 104 static void
 105 bridge_reset_primary(struct bridge_state *bst)
 106 {
 107         struct bridge_member *bm;
 108
 109         if (!bst->primary_port &&
 110             (bst->dev.settings.flags & DEV_OPT_MACADDR))
 111                 return;
 112
 113         bst->primary_port = NULL;
 114         bst->dev.settings.flags &= ~DEV_OPT_MACADDR;
 115         vlist_for_each_element(&bst->members, bm, node) {
 116                 uint8_t *macaddr;
 117
 118                 if (!bm->present)
 119                         continue;
 120
 121                 bst->primary_port = bm;
 122                 if (bm->dev.dev->settings.flags & DEV_OPT_MACADDR)
 123                         macaddr = bm->dev.dev->settings.macaddr;
 124                 else
 125                         macaddr = bm->dev.dev->orig_settings.macaddr;
 126                 memcpy(bst->dev.settings.macaddr, macaddr, 6);
 127                 bst->dev.settings.flags |= DEV_OPT_MACADDR;
 128                 return;
 129         }
 130 }
 131
 132 static int
 133 bridge_disable_member(struct bridge_member *bm)
 134 {
 135         struct bridge_state *bst = bm->bst;
 136
 137         if (!bm->present)
 138                 return 0;
 139
 140         system_bridge_delif(&bst->dev, bm->dev.dev);
 141         device_release(&bm->dev);
 142
 143         return 0;
 144 }
 145
 146 static int
 147 bridge_enable_member(struct bridge_member *bm)
 148 {
 149         struct bridge_state *bst = bm->bst;
 150         int ret;
 151
 152         if (!bm->present)
 153                 return 0;
 154
 155         ret = device_claim(&bm->dev);
 156         if (ret < 0)
 157                 goto error;
 158
 159         ret = system_bridge_addif(&bst->dev, bm->dev.dev);
 160         if (ret < 0) {
 161                 D(DEVICE, "Bridge device %s could not be added\n", bm->dev.dev->ifname);
 162                 goto error;
 163         }
 164
 165         return 0;
 166
 167 error:
 168         bm->present = false;
 169         bst->n_present--;
 170         return ret;
 171 }
 172
 173 static void
 174 bridge_remove_member(struct bridge_member *bm)
 175 {
 176         struct bridge_state *bst = bm->bst;
 177
 178         if (!bm->present)
 179                 return;
 180
 181         if (bm == bst->primary_port)
 182                 bridge_reset_primary(bst);
 183
 184         if (bst->dev.active)
 185                 bridge_disable_member(bm);
 186
 187         bm->present = false;
 188         bm->bst->n_present--;
 189
 190         if (bst->config.bridge_empty)
 191                 return;
 192
 193         bst->force_active = false;
 194         if (bst->n_present == 0)
 195                 device_set_present(&bst->dev, false);
 196 }
 197
 198 static void
 199 bridge_free_member(struct bridge_member *bm)
 200 {
 201         struct device *dev = bm->dev.dev;
 202
 203         bridge_remove_member(bm);
 204         device_remove_user(&bm->dev);
 205
 206         /*
 207          * When reloading the config and moving a device from one bridge to
 208          * another, the other bridge may have tried to claim this device
 209          * before it was removed here.
 210          * Ensure that claiming the device is retried by toggling its present
 211          * state
 212          */
 213         if (dev->present) {
 214                 device_set_present(dev, false);
 215                 device_set_present(dev, true);
 216         }
 217
 218         free(bm);
 219 }
 220
 221 static void
 222 bridge_member_cb(struct device_user *dev, enum device_event ev)
 223 {
 224         struct bridge_member *bm = container_of(dev, struct bridge_member, dev);
 225         struct bridge_state *bst = bm->bst;
 226
 227         switch (ev) {
 228         case DEV_EVENT_ADD:
 229                 assert(!bm->present);
 230
 231                 bm->present = true;
 232                 bst->n_present++;
 233
 234                 if (bst->n_present == 1)
 235                         device_set_present(&bst->dev, true);
 236                 if (bst->dev.active && !bridge_enable_member(bm)) {
 237                         /*
 238                          * Adding a bridge member can overwrite the bridge mtu
 239                          * in the kernel, apply the bridge settings in case the
 240                          * bridge mtu is set
 241                          */
 242                         system_if_apply_settings(&bst->dev, &bst->dev.settings,
 243                                                  DEV_OPT_MTU);
 244                 }
 245
 246                 break;
 247         case DEV_EVENT_REMOVE:
 248                 if (dev->hotplug) {
 249                         vlist_delete(&bst->members, &bm->node);
 250                         return;
 251                 }
 252
 253                 if (bm->present)
 254                         bridge_remove_member(bm);
 255
 256                 break;
 257         default:
 258                 return;
 259         }
 260 }
 261
 262 static int
 263 bridge_set_down(struct bridge_state *bst)
 264 {
 265         struct bridge_member *bm;
 266
 267         bst->set_state(&bst->dev, false);
 268
 269         vlist_for_each_element(&bst->members, bm, node)
 270                 bridge_disable_member(bm);
 271
 272         system_bridge_delbr(&bst->dev);
 273
 274         return 0;
 275 }
 276
 277 static int
 278 bridge_set_up(struct bridge_state *bst)
 279 {
 280         struct bridge_member *bm;
 281         int ret;
 282
 283         if (!bst->force_active && !bst->n_present)
 284                 return -ENOENT;
 285
 286         ret = system_bridge_addbr(&bst->dev, &bst->config);
 287         if (ret < 0)
 288                 goto out;
 289
 290         vlist_for_each_element(&bst->members, bm, node)
 291                 bridge_enable_member(bm);
 292
 293         if (!bst->force_active && !bst->n_present) {
 294                 /* initialization of all member interfaces failed */
 295                 system_bridge_delbr(&bst->dev);
 296                 device_set_present(&bst->dev, false);
 297                 return -ENOENT;
 298         }
 299
 300         bridge_reset_primary(bst);
 301         ret = bst->set_state(&bst->dev, true);
 302         if (ret < 0)
 303                 bridge_set_down(bst);
 304
 305 out:
 306         return ret;
 307 }
 308
 309 static int
 310 bridge_set_state(struct device *dev, bool up)
 311 {
 312         struct bridge_state *bst;
 313
 314         bst = container_of(dev, struct bridge_state, dev);
 315
 316         if (up)
 317                 return bridge_set_up(bst);
 318         else
 319                 return bridge_set_down(bst);
 320 }
 321
 322 static struct bridge_member *
 323 bridge_create_member(struct bridge_state *bst, struct device *dev, bool hotplug)
 324 {
 325         struct bridge_member *bm;
 326
 327         bm = calloc(1, sizeof(*bm) + strlen(dev->ifname) + 1);
 328         if (!bm)
 329                 return NULL;
 330
 331         bm->bst = bst;
 332         bm->dev.cb = bridge_member_cb;
 333         bm->dev.hotplug = hotplug;
 334         strcpy(bm->name, dev->ifname);
 335         bm->dev.dev = dev;
 336         vlist_add(&bst->members, &bm->node, bm->name);
 337         if (hotplug)
 338                 bm->node.version = -1;
 339
 340         return bm;
 341 }
 342
 343 static void
 344 bridge_member_update(struct vlist_tree *tree, struct vlist_node *node_new,
 345                      struct vlist_node *node_old)
 346 {
 347         struct bridge_member *bm;
 348         struct device *dev;
 349
 350         if (node_new) {
 351                 bm = container_of(node_new, struct bridge_member, node);
 352
 353                 if (node_old) {
 354                         free(bm);
 355                         return;
 356                 }
 357
 358                 dev = bm->dev.dev;
 359                 bm->dev.dev = NULL;
 360                 device_add_user(&bm->dev, dev);
 361         }
 362
 363
 364         if (node_old) {
 365                 bm = container_of(node_old, struct bridge_member, node);
 366                 bridge_free_member(bm);
 367         }
 368 }
 369
 370
 371 static void
 372 bridge_add_member(struct bridge_state *bst, const char *name)
 373 {
 374         struct device *dev;
 375
 376         dev = device_get(name, true);
 377         if (!dev)
 378                 return;
 379
 380         bridge_create_member(bst, dev, false);
 381 }
 382
 383 static int
 384 bridge_hotplug_add(struct device *dev, struct device *member)
 385 {
 386         struct bridge_state *bst = container_of(dev, struct bridge_state, dev);
 387
 388         bridge_create_member(bst, member, true);
 389
 390         return 0;
 391 }
 392
 393 static int
 394 bridge_hotplug_del(struct device *dev, struct device *member)
 395 {
 396         struct bridge_state *bst = container_of(dev, struct bridge_state, dev);
 397         struct bridge_member *bm;
 398
 399         bm = vlist_find(&bst->members, member->ifname, bm, node);
 400         if (!bm)
 401                 return UBUS_STATUS_NOT_FOUND;
 402
 403         vlist_delete(&bst->members, &bm->node);
 404         return 0;
 405 }
 406
 407 static int
 408 bridge_hotplug_prepare(struct device *dev)
 409 {
 410         struct bridge_state *bst;
 411
 412         bst = container_of(dev, struct bridge_state, dev);
 413         bst->force_active = true;
 414         device_set_present(&bst->dev, true);
 415
 416         return 0;
 417 }
 418
 419 static const struct device_hotplug_ops bridge_ops = {
 420         .prepare = bridge_hotplug_prepare,
 421         .add = bridge_hotplug_add,
 422         .del = bridge_hotplug_del
 423 };
 424
 425 static void
 426 bridge_free(struct device *dev)
 427 {
 428         struct bridge_state *bst;
 429
 430         bst = container_of(dev, struct bridge_state, dev);
 431         vlist_flush_all(&bst->members);
 432         free(bst);
 433 }
 434
 435 static void
 436 bridge_dump_info(struct device *dev, struct blob_buf *b)
 437 {
 438         struct bridge_state *bst;
 439         struct bridge_member *bm;
 440         void *list;
 441
 442         bst = container_of(dev, struct bridge_state, dev);
 443
 444         system_if_dump_info(dev, b);
 445         list = blobmsg_open_array(b, "bridge-members");
 446
 447         vlist_for_each_element(&bst->members, bm, node)
 448                 blobmsg_add_string(b, NULL, bm->dev.dev->ifname);
 449
 450         blobmsg_close_array(b, list);
 451 }
 452
 453 static void
 454 bridge_config_init(struct device *dev)
 455 {
 456         struct bridge_state *bst;
 457         struct blob_attr *cur;
 458         int rem;
 459
 460         bst = container_of(dev, struct bridge_state, dev);
 461
 462         if (bst->config.bridge_empty) {
 463                 bst->force_active = true;
 464                 device_set_present(&bst->dev, true);
 465         }
 466
 467         vlist_update(&bst->members);
 468         if (bst->ifnames) {
 469                 blobmsg_for_each_attr(cur, bst->ifnames, rem) {
 470                         bridge_add_member(bst, blobmsg_data(cur));
 471                 }
 472         }
 473         vlist_flush(&bst->members);
 474 }
 475
 476 static void
 477 bridge_apply_settings(struct bridge_state *bst, struct blob_attr **tb)
 478 {
 479         struct bridge_config *cfg = &bst->config;
 480         struct blob_attr *cur;
 481
 482         /* defaults */
 483         cfg->stp = false;
 484         cfg->forward_delay = 2;
 485         cfg->igmp_snoop = false;
 486         cfg->bridge_empty = false;
 487         cfg->priority = 0x7FFF;
 488
 489         if ((cur = tb[BRIDGE_ATTR_STP]))
 490                 cfg->stp = blobmsg_get_bool(cur);
 491
 492         if ((cur = tb[BRIDGE_ATTR_FORWARD_DELAY]))
 493                 cfg->forward_delay = blobmsg_get_u32(cur);
 494
 495         if ((cur = tb[BRIDGE_ATTR_PRIORITY]))
 496                 cfg->priority = blobmsg_get_u32(cur);
 497
 498         if ((cur = tb[BRIDGE_ATTR_IGMP_SNOOP]))
 499                 cfg->igmp_snoop = blobmsg_get_bool(cur);
 500
 501         if ((cur = tb[BRIDGE_ATTR_AGEING_TIME])) {
 502                 cfg->ageing_time = blobmsg_get_u32(cur);
 503                 cfg->flags |= BRIDGE_OPT_AGEING_TIME;
 504         }
 505
 506         if ((cur = tb[BRIDGE_ATTR_HELLO_TIME])) {
 507                 cfg->hello_time = blobmsg_get_u32(cur);
 508                 cfg->flags |= BRIDGE_OPT_HELLO_TIME;
 509         }
 510
 511         if ((cur = tb[BRIDGE_ATTR_MAX_AGE])) {
 512                 cfg->max_age = blobmsg_get_u32(cur);
 513                 cfg->flags |= BRIDGE_OPT_MAX_AGE;
 514         }
 515
 516         if ((cur = tb[BRIDGE_ATTR_BRIDGE_EMPTY]))
 517                 cfg->bridge_empty = blobmsg_get_bool(cur);
 518 }
 519
 520 enum dev_change_type
 521 bridge_reload(struct device *dev, struct blob_attr *attr)
 522 {
 523         struct blob_attr *tb_dev[__DEV_ATTR_MAX];
 524         struct blob_attr *tb_br[__BRIDGE_ATTR_MAX];
 525         enum dev_change_type ret = DEV_CONFIG_APPLIED;
 526         unsigned long diff;
 527         struct bridge_state *bst;
 528
 529         BUILD_BUG_ON(sizeof(diff) < __BRIDGE_ATTR_MAX / 8);
 530         BUILD_BUG_ON(sizeof(diff) < __DEV_ATTR_MAX / 8);
 531
 532         bst = container_of(dev, struct bridge_state, dev);
 533
 534         blobmsg_parse(device_attr_list.params, __DEV_ATTR_MAX, tb_dev,
 535                 blob_data(attr), blob_len(attr));
 536         blobmsg_parse(bridge_attrs, __BRIDGE_ATTR_MAX, tb_br,
 537                 blob_data(attr), blob_len(attr));
 538
 539         bst->ifnames = tb_br[BRIDGE_ATTR_IFNAME];
 540         device_init_settings(dev, tb_dev);
 541         bridge_apply_settings(bst, tb_br);
 542
 543         if (bst->config_data) {
 544                 struct blob_attr *otb_dev[__DEV_ATTR_MAX];
 545                 struct blob_attr *otb_br[__BRIDGE_ATTR_MAX];
 546
 547                 blobmsg_parse(device_attr_list.params, __DEV_ATTR_MAX, otb_dev,
 548                         blob_data(bst->config_data), blob_len(bst->config_data));
 549
 550                 diff = 0;
 551                 uci_blob_diff(tb_dev, otb_dev, &device_attr_list, &diff);
 552                 if (diff & ~(1 << DEV_ATTR_IFNAME))
 553                     ret = DEV_CONFIG_RESTART;
 554
 555                 blobmsg_parse(bridge_attrs, __BRIDGE_ATTR_MAX, otb_br,
 556                         blob_data(bst->config_data), blob_len(bst->config_data));
 557
 558                 diff = 0;
 559                 uci_blob_diff(tb_br, otb_br, &bridge_attr_list, &diff);
 560                 if (diff & ~(1 << BRIDGE_ATTR_IFNAME))
 561                     ret = DEV_CONFIG_RESTART;
 562
 563                 bridge_config_init(dev);
 564         }
 565
 566         bst->config_data = attr;
 567         return ret;
 568 }
 569
 570 static struct device *
 571 bridge_create(const char *name, struct blob_attr *attr)
 572 {
 573         struct bridge_state *bst;
 574         struct device *dev = NULL;
 575
 576         bst = calloc(1, sizeof(*bst));
 577         if (!bst)
 578                 return NULL;
 579
 580         dev = &bst->dev;
 581         device_init(dev, &bridge_device_type, name);
 582         dev->config_pending = true;
 583
 584         bst->set_state = dev->set_state;
 585         dev->set_state = bridge_set_state;
 586
 587         dev->hotplug_ops = &bridge_ops;
 588
 589         vlist_init(&bst->members, avl_strcmp, bridge_member_update);
 590         bst->members.keep_old = true;
 591         bridge_reload(dev, attr);
 592
 593         return dev;
 594 }