#include "netifd.h"
#include "system.h"
#include "config.h"
+#include "wireless.h"
static struct list_head devtypes = LIST_HEAD_INIT(devtypes);
static struct avl_tree devices;
[DEV_ATTR_DROP_UNSOLICITED_NA] = { .name = "drop_unsolicited_na", .type = BLOBMSG_TYPE_BOOL },
[DEV_ATTR_ARP_ACCEPT] = { .name = "arp_accept", .type = BLOBMSG_TYPE_BOOL },
[DEV_ATTR_AUTH] = { .name = "auth", .type = BLOBMSG_TYPE_BOOL },
+ [DEV_ATTR_SPEED] = { .name = "speed", .type = BLOBMSG_TYPE_INT32 },
+ [DEV_ATTR_DUPLEX] = { .name = "duplex", .type = BLOBMSG_TYPE_BOOL },
+ [DEV_ATTR_VLAN] = { .name = "vlan", .type = BLOBMSG_TYPE_ARRAY },
};
const struct uci_blob_param_list device_attr_list = {
return NULL;
}
-void device_lock(void)
-{
- __devlock++;
-}
-
-void device_unlock(void)
-{
- __devlock--;
- if (!__devlock)
- device_free_unused(NULL);
-}
-
static int device_vlan_len(struct kvlist *kv, const void *data)
{
return sizeof(unsigned int);
}
}
+void device_stp_init(void)
+{
+ struct device *dev;
+
+ avl_for_each_element(&devices, dev, avl) {
+ if (!dev->type->stp_init)
+ continue;
+
+ dev->type->stp_init(dev);
+ }
+}
+
static int set_device_state(struct device *dev, bool state)
{
if (state) {
n->arp_accept = s->flags & DEV_OPT_ARP_ACCEPT ?
s->arp_accept : os->arp_accept;
n->auth = s->flags & DEV_OPT_AUTH ? s->auth : os->auth;
+ n->speed = s->flags & DEV_OPT_SPEED ? s->speed : os->speed;
+ n->duplex = s->flags & DEV_OPT_DUPLEX ? s->duplex : os->duplex;
n->flags = s->flags | os->flags | os->valid_flags;
}
+static bool device_fill_vlan_range(struct device_vlan_range *r, const char *val)
+{
+ unsigned long cur_start, cur_end;
+ char *sep;
+
+ cur_start = strtoul(val, &sep, 0);
+ cur_end = cur_start;
+
+ if (*sep == '-')
+ cur_end = strtoul(sep + 1, &sep, 0);
+ if (*sep || cur_end < cur_start)
+ return false;
+
+ r->start = cur_start;
+ r->end = cur_end;
+
+ return true;
+}
+
+static void
+device_set_extra_vlans(struct device *dev, struct blob_attr *data)
+{
+ struct blob_attr *cur;
+ int n_vlans;
+ size_t rem;
+
+ dev->n_extra_vlan = 0;
+ if (!data)
+ return;
+
+ n_vlans = blobmsg_check_array(data, BLOBMSG_TYPE_STRING);
+ if (n_vlans < 1)
+ return;
+
+ dev->extra_vlan = realloc(dev->extra_vlan, n_vlans * sizeof(*dev->extra_vlan));
+ blobmsg_for_each_attr(cur, data, rem)
+ if (device_fill_vlan_range(&dev->extra_vlan[dev->n_extra_vlan],
+ blobmsg_get_string(cur)))
+ dev->n_extra_vlan++;
+}
+
void
device_init_settings(struct device *dev, struct blob_attr **tb)
{
s->flags |= DEV_OPT_AUTH;
}
+ if ((cur = tb[DEV_ATTR_SPEED])) {
+ s->speed = blobmsg_get_u32(cur);
+ s->flags |= DEV_OPT_SPEED;
+ }
+
+ if ((cur = tb[DEV_ATTR_DUPLEX])) {
+ s->duplex = blobmsg_get_bool(cur);
+ s->flags |= DEV_OPT_DUPLEX;
+ }
+ device_set_extra_vlans(dev, tb[DEV_ATTR_VLAN]);
device_set_disabled(dev, disabled);
}
avl_init(&devices, avl_strcmp, true, NULL);
}
+static int device_release_cb(void *ctx, struct safe_list *list)
+{
+ struct device_user *dep = container_of(list, struct device_user, list);
+
+ if (!dep->dev || !dep->claimed)
+ return 0;
+
+ device_release(dep);
+ return 0;
+}
+
static int device_broadcast_cb(void *ctx, struct safe_list *list)
{
struct device_user *dep = container_of(list, struct device_user, list);
D(DEVICE, "%s '%s' %s present\n", dev->type->name, dev->ifname, state ? "is now" : "is no longer" );
dev->sys_present = state;
device_refresh_present(dev);
+ if (!state)
+ safe_list_for_each(&dev->users, device_release_cb, NULL);
}
void device_set_link(struct device *dev, bool state)
__devlock++;
free(dev->config);
device_cleanup(dev);
+ free(dev->extra_vlan);
dev->type->free(dev);
__devlock--;
}
static void
-__device_free_unused(struct device *dev)
+__device_free_unused(struct uloop_timeout *timeout)
{
- if (!safe_list_empty(&dev->users) ||
- !safe_list_empty(&dev->aliases) ||
- dev->current_config || __devlock)
- return;
+ struct device *dev, *tmp;
- device_free(dev);
+ avl_for_each_element_safe(&devices, dev, avl, tmp) {
+ if (!safe_list_empty(&dev->users) ||
+ !safe_list_empty(&dev->aliases) ||
+ dev->current_config)
+ continue;
+
+ device_free(dev);
+ }
+}
+
+void device_free_unused(void)
+{
+ static struct uloop_timeout free_timer = {
+ .cb = __device_free_unused,
+ };
+
+ uloop_timeout_set(&free_timer, 1);
}
void device_remove_user(struct device_user *dep)
safe_list_del(&dep->list);
dep->dev = NULL;
D(DEVICE, "Remove user for device '%s', refcount=%d\n", dev->ifname, device_refcount(dev));
- __device_free_unused(dev);
-}
-
-void
-device_free_unused(struct device *dev)
-{
- struct device *tmp;
-
- if (dev)
- return __device_free_unused(dev);
-
- avl_for_each_element_safe(&devices, dev, avl, tmp)
- __device_free_unused(dev);
+ device_free_unused();
}
void
static void
device_replace(struct device *dev, struct device *odev)
{
- struct device_user *dep, *tmp;
+ struct device_user *dep;
__devlock++;
if (odev->present)
device_set_present(odev, false);
- list_for_each_entry_safe(dep, tmp, &odev->users.list, list.list) {
+ while (!list_empty(&odev->users.list)) {
+ dep = list_first_entry(&odev->users.list, struct device_user, list.list);
device_release(dep);
+ if (!dep->dev)
+ continue;
+
safe_list_del(&dep->list);
__device_add_user(dep, dev);
}
{
struct device *dev;
+ wireless_device_hotplug_event(name, add);
+
dev = device_find(name);
if (!dev || dev->type != &simple_device_type)
return;