vlandev.c

   1 /*
   2  * netifd - network interface daemon
   3  * Copyright (C) 2014 Gioacchino Mazzurco <gio@eigenlab.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
  15 #include <string.h>
  16 #include <inttypes.h>
  17
  18 #include "netifd.h"
  19 #include "device.h"
  20 #include "interface.h"
  21 #include "system.h"
  22 #include "utils.h"
  23
  24 enum {
  25         VLANDEV_ATTR_IFNAME,
  26         VLANDEV_ATTR_VID,
  27         VLANDEV_ATTR_INGRESS_QOS_MAPPING,
  28         VLANDEV_ATTR_EGRESS_QOS_MAPPING,
  29         __VLANDEV_ATTR_MAX
  30 };
  31
  32 static const struct blobmsg_policy vlandev_attrs[__VLANDEV_ATTR_MAX] = {
  33         [VLANDEV_ATTR_IFNAME] = { "ifname", BLOBMSG_TYPE_STRING },
  34         [VLANDEV_ATTR_VID] = { "vid", BLOBMSG_TYPE_INT32 },
  35         [VLANDEV_ATTR_INGRESS_QOS_MAPPING] = { "ingress_qos_mapping", BLOBMSG_TYPE_ARRAY },
  36         [VLANDEV_ATTR_EGRESS_QOS_MAPPING] = { "egress_qos_mapping", BLOBMSG_TYPE_ARRAY },
  37 };
  38
  39 static const struct uci_blob_param_list vlandev_attr_list = {
  40         .n_params = __VLANDEV_ATTR_MAX,
  41         .params = vlandev_attrs,
  42
  43         .n_next = 1,
  44         .next = { &device_attr_list },
  45 };
  46
  47 static struct device_type vlan8021q_device_type;
  48
  49 struct vlandev_device {
  50         struct device dev;
  51         struct device_user parent;
  52
  53         device_state_cb set_state;
  54
  55         struct blob_attr *config_data;
  56         struct blob_attr *ifname;
  57         struct vlandev_config config;
  58 };
  59
  60 static void
  61 vlandev_base_cb(struct device_user *dev, enum device_event ev)
  62 {
  63         struct vlandev_device *mvdev = container_of(dev, struct vlandev_device, parent);
  64
  65         switch (ev) {
  66         case DEV_EVENT_ADD:
  67                 device_set_present(&mvdev->dev, true);
  68                 break;
  69         case DEV_EVENT_REMOVE:
  70                 device_set_present(&mvdev->dev, false);
  71                 break;
  72         default:
  73                 return;
  74         }
  75 }
  76
  77 static int
  78 vlandev_set_down(struct vlandev_device *mvdev)
  79 {
  80         mvdev->set_state(&mvdev->dev, false);
  81         system_vlandev_del(&mvdev->dev);
  82         device_release(&mvdev->parent);
  83
  84         return 0;
  85 }
  86
  87 static int
  88 vlandev_set_up(struct vlandev_device *mvdev)
  89 {
  90         int ret;
  91
  92         ret = device_claim(&mvdev->parent);
  93         if (ret < 0)
  94                 return ret;
  95
  96         ret = system_vlandev_add(&mvdev->dev, mvdev->parent.dev, &mvdev->config);
  97         if (ret < 0)
  98                 goto release;
  99
 100         ret = mvdev->set_state(&mvdev->dev, true);
 101         if (ret)
 102                 goto delete;
 103
 104         return 0;
 105
 106 delete:
 107         system_vlandev_del(&mvdev->dev);
 108 release:
 109         device_release(&mvdev->parent);
 110         return ret;
 111 }
 112
 113 static int
 114 vlandev_set_state(struct device *dev, bool up)
 115 {
 116         struct vlandev_device *mvdev;
 117
 118         D(SYSTEM, "vlandev_set_state(%s, %u)\n", dev->ifname, up);
 119
 120         mvdev = container_of(dev, struct vlandev_device, dev);
 121         if (up)
 122                 return vlandev_set_up(mvdev);
 123         else
 124                 return vlandev_set_down(mvdev);
 125 }
 126
 127 static void
 128 vlandev_free(struct device *dev)
 129 {
 130         struct vlandev_device *mvdev;
 131
 132         mvdev = container_of(dev, struct vlandev_device, dev);
 133         device_remove_user(&mvdev->parent);
 134         free(mvdev->config_data);
 135         vlist_simple_flush_all(&mvdev->config.ingress_qos_mapping_list);
 136         vlist_simple_flush_all(&mvdev->config.egress_qos_mapping_list);
 137         free(mvdev);
 138 }
 139
 140 static void vlandev_qos_mapping_dump(struct blob_buf *b, const char *name, const struct vlist_simple_tree *qos_mapping_li)
 141 {
 142         const struct vlan_qos_mapping *elem;
 143         void *a, *t;
 144
 145         a = blobmsg_open_array(b, name);
 146
 147         vlist_simple_for_each_element(qos_mapping_li, elem, node) {
 148                 t = blobmsg_open_table(b, NULL);
 149
 150                 blobmsg_add_u32(b, "from", elem->from);
 151                 blobmsg_add_u32(b, "to", elem->to);
 152
 153                 blobmsg_close_table(b, t);
 154         }
 155
 156         blobmsg_close_array(b, a);
 157 }
 158
 159 static void
 160 vlandev_dump_info(struct device *dev, struct blob_buf *b)
 161 {
 162         struct vlandev_device *mvdev;
 163
 164         mvdev = container_of(dev, struct vlandev_device, dev);
 165         blobmsg_add_string(b, "parent", mvdev->parent.dev->ifname);
 166         system_if_dump_info(dev, b);
 167         vlandev_qos_mapping_dump(b, "ingress_qos_mapping", &mvdev->config.ingress_qos_mapping_list);
 168         vlandev_qos_mapping_dump(b, "egress_qos_mapping", &mvdev->config.egress_qos_mapping_list);
 169 }
 170
 171 static void
 172 vlandev_config_init(struct device *dev)
 173 {
 174         struct vlandev_device *mvdev;
 175         struct device *basedev = NULL;
 176
 177         mvdev = container_of(dev, struct vlandev_device, dev);
 178         if (mvdev->ifname)
 179                 basedev = device_get(blobmsg_data(mvdev->ifname), true);
 180
 181         device_add_user(&mvdev->parent, basedev);
 182 }
 183
 184 static void vlandev_qos_mapping_list_apply(struct vlist_simple_tree *qos_mapping_li, struct blob_attr *list)
 185 {
 186         struct blob_attr *cur;
 187         struct vlan_qos_mapping *qos_mapping;
 188         int rem, rc;
 189
 190         blobmsg_for_each_attr(cur, list, rem) {
 191                 if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING)
 192                         continue;
 193
 194                 if (!blobmsg_check_attr(cur, false))
 195                         continue;
 196
 197                 qos_mapping = calloc(1, sizeof(*qos_mapping));
 198                 if (!qos_mapping)
 199                         continue;
 200
 201                 rc = sscanf(blobmsg_data(cur), "%" PRIu32 ":%" PRIu32, &qos_mapping->from, &qos_mapping->to);
 202                 if (rc != 2) {
 203                         free(qos_mapping);
 204                         continue;
 205                 }
 206                 vlist_simple_add(qos_mapping_li, &qos_mapping->node);
 207         }
 208 }
 209
 210 static void
 211 vlandev_apply_settings(struct vlandev_device *mvdev, struct blob_attr **tb)
 212 {
 213         struct vlandev_config *cfg = &mvdev->config;
 214         struct blob_attr *cur;
 215
 216         cfg->proto = (mvdev->dev.type == &vlan8021q_device_type) ?
 217                 VLAN_PROTO_8021Q : VLAN_PROTO_8021AD;
 218         cfg->vid = 1;
 219
 220         vlist_simple_update(&cfg->ingress_qos_mapping_list);
 221         vlist_simple_update(&cfg->egress_qos_mapping_list);
 222
 223         if ((cur = tb[VLANDEV_ATTR_VID]))
 224                 cfg->vid = (uint16_t) blobmsg_get_u32(cur);
 225
 226         if ((cur = tb[VLANDEV_ATTR_INGRESS_QOS_MAPPING]))
 227                 vlandev_qos_mapping_list_apply(&cfg->ingress_qos_mapping_list, cur);
 228
 229         if ((cur = tb[VLANDEV_ATTR_EGRESS_QOS_MAPPING]))
 230                 vlandev_qos_mapping_list_apply(&cfg->egress_qos_mapping_list, cur);
 231
 232         vlist_simple_flush(&cfg->ingress_qos_mapping_list);
 233         vlist_simple_flush(&cfg->egress_qos_mapping_list);
 234 }
 235
 236 static enum dev_change_type
 237 vlandev_reload(struct device *dev, struct blob_attr *attr)
 238 {
 239         struct blob_attr *tb_dev[__DEV_ATTR_MAX];
 240         struct blob_attr *tb_mv[__VLANDEV_ATTR_MAX];
 241         enum dev_change_type ret = DEV_CONFIG_APPLIED;
 242         struct vlandev_device *mvdev;
 243
 244         mvdev = container_of(dev, struct vlandev_device, dev);
 245         attr = blob_memdup(attr);
 246
 247         blobmsg_parse(device_attr_list.params, __DEV_ATTR_MAX, tb_dev,
 248                 blob_data(attr), blob_len(attr));
 249         blobmsg_parse(vlandev_attrs, __VLANDEV_ATTR_MAX, tb_mv,
 250                 blob_data(attr), blob_len(attr));
 251
 252         device_init_settings(dev, tb_dev);
 253         vlandev_apply_settings(mvdev, tb_mv);
 254         mvdev->ifname = tb_mv[VLANDEV_ATTR_IFNAME];
 255
 256         if (mvdev->config_data) {
 257                 struct blob_attr *otb_dev[__DEV_ATTR_MAX];
 258                 struct blob_attr *otb_mv[__VLANDEV_ATTR_MAX];
 259
 260                 blobmsg_parse(device_attr_list.params, __DEV_ATTR_MAX, otb_dev,
 261                         blob_data(mvdev->config_data), blob_len(mvdev->config_data));
 262
 263                 if (uci_blob_diff(tb_dev, otb_dev, &device_attr_list, NULL))
 264                     ret = DEV_CONFIG_RESTART;
 265
 266                 blobmsg_parse(vlandev_attrs, __VLANDEV_ATTR_MAX, otb_mv,
 267                         blob_data(mvdev->config_data), blob_len(mvdev->config_data));
 268
 269                 if (uci_blob_diff(tb_mv, otb_mv, &vlandev_attr_list, NULL))
 270                     ret = DEV_CONFIG_RESTART;
 271
 272                 vlandev_config_init(dev);
 273         }
 274
 275         free(mvdev->config_data);
 276         mvdev->config_data = attr;
 277         return ret;
 278 }
 279
 280 static struct device *
 281 vlandev_create(const char *name, struct device_type *devtype,
 282                struct blob_attr *attr)
 283 {
 284         struct vlandev_device *mvdev;
 285         struct device *dev = NULL;
 286
 287         mvdev = calloc(1, sizeof(*mvdev));
 288         if (!mvdev)
 289                 return NULL;
 290
 291         vlist_simple_init(&mvdev->config.ingress_qos_mapping_list,
 292                           struct vlan_qos_mapping, node);
 293         vlist_simple_init(&mvdev->config.egress_qos_mapping_list,
 294                           struct vlan_qos_mapping, node);
 295
 296         dev = &mvdev->dev;
 297
 298         if (device_init(dev, devtype, name) < 0) {
 299                 device_cleanup(dev);
 300                 free(mvdev);
 301                 return NULL;
 302         }
 303
 304         dev->config_pending = true;
 305
 306         mvdev->set_state = dev->set_state;
 307         dev->set_state = vlandev_set_state;
 308
 309         dev->hotplug_ops = NULL;
 310         mvdev->parent.cb = vlandev_base_cb;
 311
 312         vlandev_reload(dev, attr);
 313
 314         return dev;
 315 }
 316
 317 static struct device_type vlan8021ad_device_type = {
 318         .name = "8021ad",
 319         .config_params = &vlandev_attr_list,
 320         .create = vlandev_create,
 321         .config_init = vlandev_config_init,
 322         .reload = vlandev_reload,
 323         .free = vlandev_free,
 324         .dump_info = vlandev_dump_info,
 325 };
 326
 327 static struct device_type vlan8021q_device_type = {
 328         .name = "8021q",
 329         .config_params = &vlandev_attr_list,
 330         .create = vlandev_create,
 331         .config_init = vlandev_config_init,
 332         .reload = vlandev_reload,
 333         .free = vlandev_free,
 334         .dump_info = vlandev_dump_info,
 335 };
 336
 337 static void __init vlandev_device_type_init(void)
 338 {
 339         device_type_add(&vlan8021ad_device_type);
 340         device_type_add(&vlan8021q_device_type);
 341 }