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