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