#include "system.h"
enum {
- BRIDGE_ATTR_IFNAME,
+ BRIDGE_ATTR_PORTS,
BRIDGE_ATTR_STP,
BRIDGE_ATTR_FORWARD_DELAY,
BRIDGE_ATTR_PRIORITY,
};
static const struct blobmsg_policy bridge_attrs[__BRIDGE_ATTR_MAX] = {
- [BRIDGE_ATTR_IFNAME] = { "ifname", BLOBMSG_TYPE_ARRAY },
+ [BRIDGE_ATTR_PORTS] = { "ports", BLOBMSG_TYPE_ARRAY },
[BRIDGE_ATTR_STP] = { "stp", BLOBMSG_TYPE_BOOL },
[BRIDGE_ATTR_FORWARD_DELAY] = { "forward_delay", BLOBMSG_TYPE_INT32 },
[BRIDGE_ATTR_PRIORITY] = { "priority", BLOBMSG_TYPE_INT32 },
};
static const struct uci_blob_param_info bridge_attr_info[__BRIDGE_ATTR_MAX] = {
- [BRIDGE_ATTR_IFNAME] = { .type = BLOBMSG_TYPE_STRING },
+ [BRIDGE_ATTR_PORTS] = { .type = BLOBMSG_TYPE_STRING },
};
static const struct uci_blob_param_list bridge_attr_list = {
static struct device *bridge_create(const char *name, struct device_type *devtype,
struct blob_attr *attr);
static void bridge_config_init(struct device *dev);
+static void bridge_dev_vlan_update(struct device *dev);
static void bridge_free(struct device *dev);
static void bridge_dump_info(struct device *dev, struct blob_buf *b);
static enum dev_change_type
.create = bridge_create,
.config_init = bridge_config_init,
+ .vlan_update = bridge_dev_vlan_update,
.reload = bridge_reload,
.free = bridge_free,
.dump_info = bridge_dump_info,
struct blob_attr *config_data;
struct bridge_config config;
- struct blob_attr *ifnames;
+ struct blob_attr *ports;
bool active;
bool force_active;
bool has_vlans;
struct device_user dev;
uint16_t pvid;
bool present;
+ bool active;
char name[];
};
}
static int
-bridge_disable_member(struct bridge_member *bm)
+bridge_disable_member(struct bridge_member *bm, bool keep_dev)
{
struct bridge_state *bst = bm->bst;
struct bridge_vlan *vlan;
- if (!bm->present)
+ if (!bm->present || !bm->active)
return 0;
+ bm->active = false;
vlist_for_each_element(&bst->dev.vlans, vlan, node)
bridge_set_member_vlan(bm, vlan, false);
system_bridge_delif(&bst->dev, bm->dev.dev);
- device_release(&bm->dev);
+ if (!keep_dev)
+ device_release(&bm->dev);
device_broadcast_event(&bst->dev, DEV_EVENT_TOPO_CHANGE);
{
struct bridge_state *bst = bm->bst;
struct bridge_vlan *vlan;
+ struct device *dev;
int ret;
if (!bm->present)
if (ret < 0)
goto error;
+ dev = bm->dev.dev;
+ if (dev->settings.auth && !dev->auth_status)
+ return -1;
+
+ if (bm->active)
+ return 0;
+
ret = system_bridge_addif(&bst->dev, bm->dev.dev);
if (ret < 0) {
D(DEVICE, "Bridge device %s could not be added\n", bm->dev.dev->ifname);
goto error;
}
+ bm->active = true;
if (bst->has_vlans) {
/* delete default VLAN 1 */
system_bridge_vlan(bm->dev.dev->ifname, 1, false, 0);
return;
if (bst->dev.active)
- bridge_disable_member(bm);
+ bridge_disable_member(bm, false);
bm->present = false;
bm->bst->n_present--;
bridge_remove_member(bm);
+restart:
vlist_for_each_element(&bst->dev.vlans, vlan, node) {
struct bridge_vlan_hotplug_port *port, *tmp;
+ bool free_port = false;
list_for_each_entry_safe(port, tmp, &vlan->hotplug_ports, list) {
if (strcmp(port->port.ifname, ifname) != 0)
list_del(&port->list);
free(port);
+ free_port = true;
}
+
+ if (!free_port || !list_empty(&vlan->hotplug_ports) ||
+ vlan->n_ports || vlan->node.version != -1)
+ continue;
+
+ vlist_delete(&bst->dev.vlans, &vlan->node);
+ goto restart;
}
device_lock();
}
static void
-bridge_member_cb(struct device_user *dev, enum device_event ev)
+bridge_member_cb(struct device_user *dep, enum device_event ev)
{
- struct bridge_member *bm = container_of(dev, struct bridge_member, dev);
+ struct bridge_member *bm = container_of(dep, struct bridge_member, dev);
struct bridge_state *bst = bm->bst;
+ struct device *dev = dep->dev;
switch (ev) {
case DEV_EVENT_ADD:
if (bst->n_present == 1)
device_set_present(&bst->dev, true);
- if (bst->dev.active && !bridge_enable_member(bm)) {
- /*
- * Adding a bridge member can overwrite the bridge mtu
- * in the kernel, apply the bridge settings in case the
- * bridge mtu is set
- */
- system_if_apply_settings(&bst->dev, &bst->dev.settings,
- DEV_OPT_MTU | DEV_OPT_MTU6);
- }
+ fallthrough;
+ case DEV_EVENT_AUTH_UP:
+ if (!bst->dev.active)
+ break;
+
+ if (bridge_enable_member(bm))
+ break;
+
+ /*
+ * Adding a bridge member can overwrite the bridge mtu
+ * in the kernel, apply the bridge settings in case the
+ * bridge mtu is set
+ */
+ system_if_apply_settings(&bst->dev, &bst->dev.settings,
+ DEV_OPT_MTU | DEV_OPT_MTU6);
+ break;
+ case DEV_EVENT_LINK_DOWN:
+ if (!dev->settings.auth)
+ break;
+ bridge_disable_member(bm, true);
break;
case DEV_EVENT_REMOVE:
- if (dev->hotplug) {
+ if (dep->hotplug) {
vlist_delete(&bst->members, &bm->node);
return;
}
bst->set_state(&bst->dev, false);
vlist_for_each_element(&bst->members, bm, node)
- bridge_disable_member(bm);
+ bridge_disable_member(bm, false);
bridge_disable_interface(bst);
bridge_create_member(bst, name, dev, false);
}
+static struct bridge_vlan *
+bridge_hotplug_get_vlan(struct bridge_state *bst, unsigned int vid)
+{
+ struct bridge_vlan *vlan;
+
+ vlan = vlist_find(&bst->dev.vlans, &vid, vlan, node);
+ if (vlan)
+ return vlan;
+
+ vlan = calloc(1, sizeof(*vlan));
+ vlan->vid = vid;
+ vlan->local = true;
+ INIT_LIST_HEAD(&vlan->hotplug_ports);
+ vlist_add(&bst->dev.vlans, &vlan->node, &vlan->vid);
+ vlan->node.version = -1;
+
+ return vlan;
+}
+
+static struct bridge_vlan_hotplug_port *
+bridge_hotplug_get_vlan_port(struct bridge_vlan *vlan, const char *ifname)
+{
+ struct bridge_vlan_hotplug_port *port;
+
+ list_for_each_entry(port, &vlan->hotplug_ports, list)
+ if (!strcmp(port->port.ifname, ifname))
+ return port;
+
+ return NULL;
+}
+
static void
-bridge_hotplug_create_member_vlans(struct bridge_state *bst, struct blob_attr *vlans, const char *ifname)
+bridge_hotplug_set_member_vlans(struct bridge_state *bst, struct blob_attr *vlans,
+ const char *ifname, struct bridge_member *bm, bool add)
{
struct bridge_vlan *vlan;
struct blob_attr *cur;
if (!vid || vid > 4095)
continue;
- vlan = vlist_find(&bst->dev.vlans, &vid, vlan, node);
+ vlan = bridge_hotplug_get_vlan(bst, vid);
if (!vlan)
continue;
}
}
+ port = bridge_hotplug_get_vlan_port(vlan, ifname);
+ if (!add) {
+ if (!port)
+ continue;
+
+ __bridge_set_member_vlan(bm, vlan, &port->port, false);
+ list_del(&port->list);
+ free(port);
+ continue;
+ }
+
+ if (port) {
+ if (port->port.flags == flags)
+ continue;
+
+ __bridge_set_member_vlan(bm, vlan, &port->port, false);
+ port->port.flags = flags;
+ __bridge_set_member_vlan(bm, vlan, &port->port, true);
+ continue;
+ }
+
port = calloc_a(sizeof(*port), &name_buf, strlen(ifname) + 1);
if (!port)
continue;
port->port.flags = flags;
port->port.ifname = strcpy(name_buf, ifname);
list_add_tail(&port->list, &vlan->hotplug_ports);
+
+ if (!bm)
+ continue;
+
+ __bridge_set_member_vlan(bm, vlan, &port->port, true);
}
}
bridge_hotplug_add(struct device *dev, struct device *member, struct blob_attr *vlan)
{
struct bridge_state *bst = container_of(dev, struct bridge_state, dev);
+ struct bridge_member *bm;
- bridge_hotplug_create_member_vlans(bst, vlan, member->ifname);
- bridge_create_member(bst, member->ifname, member, true);
+ bm = vlist_find(&bst->members, member->ifname, bm, node);
+ bridge_hotplug_set_member_vlans(bst, vlan, member->ifname, bm, true);
+ if (!bm)
+ bridge_create_member(bst, member->ifname, member, true);
return 0;
}
static int
-bridge_hotplug_del(struct device *dev, struct device *member)
+bridge_hotplug_del(struct device *dev, struct device *member, struct blob_attr *vlan)
{
struct bridge_state *bst = container_of(dev, struct bridge_state, dev);
struct bridge_member *bm;
if (!bm)
return UBUS_STATUS_NOT_FOUND;
+ bridge_hotplug_set_member_vlans(bst, vlan, member->ifname, bm, false);
+ if (!bm->dev.hotplug)
+ return 0;
+
vlist_delete(&bst->members, &bm->node);
return 0;
}
bst->n_failed = 0;
vlist_update(&bst->members);
- if (bst->ifnames) {
- blobmsg_for_each_attr(cur, bst->ifnames, rem) {
+ if (bst->ports) {
+ blobmsg_for_each_attr(cur, bst->ports, rem) {
bridge_add_member(bst, blobmsg_data(cur));
}
}
if (tb_dev[DEV_ATTR_MACADDR])
bst->primary_port = NULL;
- bst->ifnames = tb_br[BRIDGE_ATTR_IFNAME];
+ bst->ports = tb_br[BRIDGE_ATTR_PORTS];
device_init_settings(dev, tb_dev);
bridge_apply_settings(bst, tb_br);
diff = 0;
uci_blob_diff(tb_br, otb_br, &bridge_attr_list, &diff);
- if (diff & ~(1 << BRIDGE_ATTR_IFNAME))
+ if (diff & ~(1 << BRIDGE_ATTR_PORTS))
ret = DEV_CONFIG_RESTART;
bridge_config_init(dev);
list_splice_init(&vlan_old->hotplug_ports, &vlan_new->hotplug_ports);
if (node_new)
- bridge_set_vlan_state(bst, vlan_new, true);
+ vlan_new->pending = true;
bst->dev.config_pending = true;
bridge_vlan_free(vlan_old);
}
+static void
+bridge_dev_vlan_update(struct device *dev)
+{
+ struct bridge_state *bst = container_of(dev, struct bridge_state, dev);
+ struct bridge_vlan *vlan;
+
+ vlist_for_each_element(&dev->vlans, vlan, node) {
+ if (!vlan->pending)
+ continue;
+
+ vlan->pending = false;
+ bridge_set_vlan_state(bst, vlan, true);
+ }
+}
+
static struct device *
bridge_create(const char *name, struct device_type *devtype,
struct blob_attr *attr)
projects / project / netifd.git / blobdiff