char name[];
};
-static const struct device_type alias_device_type;
+static struct device_type alias_device_type;
static void alias_set_device(struct alias_device *alias, struct device *dev)
{
}
static struct device *
-alias_device_create(const char *name, struct blob_attr *attr)
+alias_device_create(const char *name, struct device_type *devtype,
+ struct blob_attr *attr)
{
struct alias_device *alias;
strcpy(alias->name, name);
alias->dev.set_state = alias_device_set_state;
alias->dev.hidden = true;
- device_init_virtual(&alias->dev, &alias_device_type, NULL);
+ device_init_virtual(&alias->dev, devtype, NULL);
alias->avl.key = alias->name;
avl_insert(&aliases, &alias->avl);
alias->dep.alias = true;
return 0;
}
-static const struct device_type alias_device_type = {
+static struct device_type alias_device_type = {
.name = "Network alias",
.create = alias_device_create,
.free = alias_device_free,
if (alias)
return &alias->dev;
- return alias_device_create(name, NULL);
+ return alias_device_create(name, &alias_device_type, NULL);
}
static void __init alias_init(void)
.next = { &device_attr_list },
};
-static struct device *bridge_create(const char *name, struct blob_attr *attr);
+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_free(struct device *dev);
static void bridge_dump_info(struct device *dev, struct blob_buf *b);
enum dev_change_type
bridge_reload(struct device *dev, struct blob_attr *attr);
-const struct device_type bridge_device_type = {
- .name = "Bridge",
+struct device_type bridge_device_type = {
+ .name = "bridge",
.config_params = &bridge_attr_list,
.create = bridge_create,
}
static struct device *
-bridge_create(const char *name, struct blob_attr *attr)
+bridge_create(const char *name, struct device_type *devtype,
+ struct blob_attr *attr)
{
struct bridge_state *bst;
struct device *dev = NULL;
return NULL;
dev = &bst->dev;
- device_init(dev, &bridge_device_type, name);
+ device_init(dev, devtype, name);
dev->config_pending = true;
bst->retry.cb = bridge_retry_members;
uci_foreach_element(&uci_network->sections, e) {
const struct uci_blob_param_list *params = NULL;
struct uci_section *s = uci_to_section(e);
- const struct device_type *devtype = NULL;
+ struct device_type *devtype = NULL;
struct device *dev;
const char *type, *name;
}
static struct device *
-simple_device_create(const char *name, struct blob_attr *attr)
+simple_device_create(const char *name, struct device_type *devtype,
+ struct blob_attr *attr)
{
struct blob_attr *tb[__DEV_ATTR_MAX];
struct device *dev = NULL;
+ /* device type is unused for simple devices */
+ devtype = NULL;
+
blobmsg_parse(dev_attrs, __DEV_ATTR_MAX, tb, blob_data(attr), blob_len(attr));
dev = device_get(name, true);
if (!dev)
free(dev);
}
-const struct device_type simple_device_type = {
+struct device_type simple_device_type = {
.name = "Network device",
.config_params = &device_attr_list,
return dev->type->check_state(dev);
}
-void device_init_virtual(struct device *dev, const struct device_type *type, const char *name)
+void device_init_virtual(struct device *dev, struct device_type *type, const char *name)
{
assert(dev);
assert(type);
dev->set_state = set_device_state;
}
-int device_init(struct device *dev, const struct device_type *type, const char *ifname)
+int device_init(struct device *dev, struct device_type *type, const char *ifname)
{
int ret;
}
static enum dev_change_type
-device_set_config(struct device *dev, const struct device_type *type,
+device_set_config(struct device *dev, struct device_type *type,
struct blob_attr *attr)
{
struct blob_attr *tb[__DEV_ATTR_MAX];
}
enum dev_change_type
-device_apply_config(struct device *dev, const struct device_type *type,
+device_apply_config(struct device *dev, struct device_type *type,
struct blob_attr *config)
{
enum dev_change_type change;
}
struct device *
-device_create(const char *name, const struct device_type *type,
+device_create(const char *name, struct device_type *type,
struct blob_attr *config)
{
struct device *odev = NULL, *dev;
if (!config)
return NULL;
- dev = type->create(name, config);
+ dev = type->create(name, type, config);
if (!dev)
return NULL;
const struct uci_blob_param_list *config_params;
- struct device *(*create)(const char *name, struct blob_attr *attr);
+ struct device *(*create)(const char *name, struct device_type *devtype,
+ struct blob_attr *attr);
void (*config_init)(struct device *);
enum dev_change_type (*reload)(struct device *, struct blob_attr *);
void (*dump_info)(struct device *, struct blob_buf *buf);
* can be used to support VLANs as well
*/
struct device {
- const struct device_type *type;
+ struct device_type *type;
struct avl_node avl;
struct safe_list users;
};
extern const struct uci_blob_param_list device_attr_list;
-extern const struct device_type simple_device_type;
-extern const struct device_type bridge_device_type;
-extern const struct device_type tunnel_device_type;
-extern const struct device_type macvlan_device_type;
-extern const struct device_type vlandev_device_type;
+extern struct device_type simple_device_type;
+extern struct device_type bridge_device_type;
+extern struct device_type tunnel_device_type;
+extern struct device_type macvlan_device_type;
+extern struct device_type vlandev_device_type;
void device_lock(void);
void device_unlock(void);
-struct device *device_create(const char *name, const struct device_type *type,
+struct device *device_create(const char *name, struct device_type *type,
struct blob_attr *config);
void device_init_settings(struct device *dev, struct blob_attr **tb);
void device_init_pending(void);
enum dev_change_type
-device_apply_config(struct device *dev, const struct device_type *type,
+device_apply_config(struct device *dev, struct device_type *type,
struct blob_attr *config);
void device_reset_config(void);
void device_reset_old(void);
void device_set_default_ps(bool state);
-void device_init_virtual(struct device *dev, const struct device_type *type, const char *name);
-int device_init(struct device *iface, const struct device_type *type, const char *ifname);
+void device_init_virtual(struct device *dev, struct device_type *type, const char *name);
+int device_init(struct device *iface, struct device_type *type, const char *ifname);
void device_cleanup(struct device *dev);
struct device *device_find(const char *name);
struct device *device_get(const char *name, int create);
}
static struct device *
-macvlan_create(const char *name, struct blob_attr *attr)
+macvlan_create(const char *name, struct device_type *devtype,
+ struct blob_attr *attr)
{
struct macvlan_device *mvdev;
struct device *dev = NULL;
return NULL;
dev = &mvdev->dev;
- device_init(dev, &macvlan_device_type, name);
+ device_init(dev, devtype, name);
dev->config_pending = true;
mvdev->set_state = dev->set_state;
return dev;
}
-const struct device_type macvlan_device_type = {
+struct device_type macvlan_device_type = {
.name = "MAC VLAN",
.config_params = &macvlan_attr_list,
.create = macvlan_create,
}
static struct device *
-tunnel_create(const char *name, struct blob_attr *attr)
+tunnel_create(const char *name, struct device_type *devtype,
+ struct blob_attr *attr)
{
struct tunnel *tun;
struct device *dev;
return NULL;
dev = &tun->dev;
- device_init(dev, &tunnel_device_type, name);
+ device_init(dev, devtype, name);
tun->set_state = dev->set_state;
dev->set_state = tunnel_set_state;
- device_apply_config(dev, &tunnel_device_type, attr);
+ device_apply_config(dev, devtype, attr);
device_set_present(dev, true);
return dev;
free(tun);
}
-const struct device_type tunnel_device_type = {
+struct device_type tunnel_device_type = {
.name = "IP tunnel",
.config_params = &tunnel_attr_list,
.reload = tunnel_reload,
if (iface->ip4table)
blobmsg_add_u32(&b, "ip4table", iface->ip4table);
if (iface->ip6table)
- blobmsg_add_u32(&b, "ip6table", iface->ip6table);
+ blobmsg_add_u32(&b, "ip6table", iface->ip6table);
blobmsg_add_u32(&b, "metric", iface->metric);
blobmsg_add_u8(&b, "delegation", !iface->proto_ip.no_delegation);
a = blobmsg_open_array(&b, "ipv4-address");
static struct device *get_vlan_device(struct device *dev, int id, bool create)
{
- static const struct device_type vlan_type = {
+ static struct device_type vlan_type = {
.name = "VLAN",
.config_params = &device_attr_list,
.free = free_vlan_if,
}
static struct device *
-vlandev_create(const char *name, struct blob_attr *attr)
+vlandev_create(const char *name, struct device_type *devtype,
+ struct blob_attr *attr)
{
struct vlandev_device *mvdev;
struct device *dev = NULL;
return NULL;
dev = &mvdev->dev;
- device_init(dev, &vlandev_device_type, name);
+ device_init(dev, devtype, name);
dev->config_pending = true;
mvdev->set_state = dev->set_state;
return dev;
}
-const struct device_type vlandev_device_type = {
+struct device_type vlandev_device_type = {
.name = "VLANDEV",
.config_params = &vlandev_attr_list,
.create = vlandev_create,