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 static struct blob_buf b;
  49
  50 struct vlandev_device {
  51         struct device dev;
  52         struct device_user parent;
  53
  54         device_state_cb set_state;
  55
  56         struct blob_attr *config_data;
  57         struct blob_attr *ifname;
  58         struct vlandev_config config;
  59 };
  60
  61 static int
  62 vlandev_hotplug_add(struct device *dev, struct device *member, struct blob_attr *vlan)
  63 {
  64         struct vlandev_device *mvdev = container_of(dev, struct vlandev_device, dev);
  65         void *a;
  66
  67         dev = mvdev->parent.dev;
  68         if (!dev || !dev->hotplug_ops)
  69                 return UBUS_STATUS_NOT_SUPPORTED;
  70
  71         blob_buf_init(&b, 0);
  72         a = blobmsg_open_array(&b, "vlans");
  73         blobmsg_printf(&b, NULL, "%d", mvdev->config.vid);
  74         blobmsg_close_array(&b, a);
  75
  76         return dev->hotplug_ops->add(dev, member, blobmsg_data(b.head));
  77 }
  78
  79 static int
  80 vlandev_hotplug_del(struct device *dev, struct device *member)
  81 {
  82         struct vlandev_device *mvdev = container_of(dev, struct vlandev_device, dev);
  83
  84         dev = mvdev->parent.dev;
  85         if (!dev || !dev->hotplug_ops)
  86                 return UBUS_STATUS_NOT_SUPPORTED;
  87
  88         return dev->hotplug_ops->del(dev, member);
  89 }
  90
  91 static int
  92 vlandev_hotplug_prepare(struct device *dev, struct device **bridge_dev)
  93 {
  94         struct vlandev_device *mvdev = container_of(dev, struct vlandev_device, dev);
  95
  96         dev = mvdev->parent.dev;
  97         if (!dev || !dev->hotplug_ops)
  98                 return UBUS_STATUS_NOT_SUPPORTED;
  99
 100         return dev->hotplug_ops->prepare(dev, bridge_dev);
 101 }
 102
 103 static void vlandev_hotplug_check(struct vlandev_device *mvdev)
 104 {
 105         static const struct device_hotplug_ops hotplug_ops = {
 106                 .prepare = vlandev_hotplug_prepare,
 107                 .add = vlandev_hotplug_add,
 108                 .del = vlandev_hotplug_del
 109         };
 110         struct device *dev = mvdev->parent.dev;
 111
 112         if (!dev || !dev->hotplug_ops || avl_is_empty(&dev->vlans.avl) ||
 113                 dev->type != &vlan8021q_device_type) {
 114                 mvdev->dev.hotplug_ops = NULL;
 115                 return;
 116         }
 117
 118         mvdev->dev.hotplug_ops = &hotplug_ops;
 119 }
 120
 121
 122 static void
 123 vlandev_base_cb(struct device_user *dev, enum device_event ev)
 124 {
 125         struct vlandev_device *mvdev = container_of(dev, struct vlandev_device, parent);
 126
 127         switch (ev) {
 128         case DEV_EVENT_ADD:
 129                 device_set_present(&mvdev->dev, true);
 130                 break;
 131         case DEV_EVENT_REMOVE:
 132                 device_set_present(&mvdev->dev, false);
 133                 break;
 134         case DEV_EVENT_UPDATE_IFNAME:
 135                 vlandev_hotplug_check(mvdev);
 136                 break;
 137         default:
 138                 return;
 139         }
 140 }
 141
 142 static int
 143 vlandev_set_down(struct vlandev_device *mvdev)
 144 {
 145         mvdev->set_state(&mvdev->dev, false);
 146         system_vlandev_del(&mvdev->dev);
 147         device_release(&mvdev->parent);
 148
 149         return 0;
 150 }
 151
 152 static int
 153 vlandev_set_up(struct vlandev_device *mvdev)
 154 {
 155         int ret;
 156
 157         ret = device_claim(&mvdev->parent);
 158         if (ret < 0)
 159                 return ret;
 160
 161         ret = system_vlandev_add(&mvdev->dev, mvdev->parent.dev, &mvdev->config);
 162         if (ret < 0)
 163                 goto release;
 164
 165         ret = mvdev->set_state(&mvdev->dev, true);
 166         if (ret)
 167                 goto delete;
 168
 169         return 0;
 170
 171 delete:
 172         system_vlandev_del(&mvdev->dev);
 173 release:
 174         device_release(&mvdev->parent);
 175         return ret;
 176 }
 177
 178 static int
 179 vlandev_set_state(struct device *dev, bool up)
 180 {
 181         struct vlandev_device *mvdev;
 182
 183         D(SYSTEM, "vlandev_set_state(%s, %u)\n", dev->ifname, up);
 184
 185         mvdev = container_of(dev, struct vlandev_device, dev);
 186         if (up)
 187                 return vlandev_set_up(mvdev);
 188         else
 189                 return vlandev_set_down(mvdev);
 190 }
 191
 192 static void
 193 vlandev_free(struct device *dev)
 194 {
 195         struct vlandev_device *mvdev;
 196
 197         mvdev = container_of(dev, struct vlandev_device, dev);
 198         device_remove_user(&mvdev->parent);
 199         free(mvdev->config_data);
 200         vlist_simple_flush_all(&mvdev->config.ingress_qos_mapping_list);
 201         vlist_simple_flush_all(&mvdev->config.egress_qos_mapping_list);
 202         free(mvdev);
 203 }
 204
 205 static void vlandev_qos_mapping_dump(struct blob_buf *b, const char *name, const struct vlist_simple_tree *qos_mapping_li)
 206 {
 207         const struct vlan_qos_mapping *elem;
 208         void *a, *t;
 209
 210         a = blobmsg_open_array(b, name);
 211
 212         vlist_simple_for_each_element(qos_mapping_li, elem, node) {
 213                 t = blobmsg_open_table(b, NULL);
 214
 215                 blobmsg_add_u32(b, "from", elem->from);
 216                 blobmsg_add_u32(b, "to", elem->to);
 217
 218                 blobmsg_close_table(b, t);
 219         }
 220
 221         blobmsg_close_array(b, a);
 222 }
 223
 224 static void
 225 vlandev_dump_info(struct device *dev, struct blob_buf *b)
 226 {
 227         struct vlandev_device *mvdev;
 228
 229         mvdev = container_of(dev, struct vlandev_device, dev);
 230         blobmsg_add_string(b, "parent", mvdev->parent.dev->ifname);
 231         system_if_dump_info(dev, b);
 232         vlandev_qos_mapping_dump(b, "ingress_qos_mapping", &mvdev->config.ingress_qos_mapping_list);
 233         vlandev_qos_mapping_dump(b, "egress_qos_mapping", &mvdev->config.egress_qos_mapping_list);
 234 }
 235
 236 static void
 237 vlandev_config_init(struct device *dev)
 238 {
 239         struct vlandev_device *mvdev;
 240         struct device *basedev = NULL;
 241
 242         mvdev = container_of(dev, struct vlandev_device, dev);
 243         if (mvdev->ifname)
 244                 basedev = device_get(blobmsg_data(mvdev->ifname), true);
 245
 246         device_add_user(&mvdev->parent, basedev);
 247         vlandev_hotplug_check(mvdev);
 248 }
 249
 250 static void vlandev_qos_mapping_list_apply(struct vlist_simple_tree *qos_mapping_li, struct blob_attr *list)
 251 {
 252         struct blob_attr *cur;
 253         struct vlan_qos_mapping *qos_mapping;
 254         int rem, rc;
 255
 256         blobmsg_for_each_attr(cur, list, rem) {
 257                 if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING)
 258                         continue;
 259
 260                 if (!blobmsg_check_attr(cur, false))
 261                         continue;
 262
 263                 qos_mapping = calloc(1, sizeof(*qos_mapping));
 264                 if (!qos_mapping)
 265                         continue;
 266
 267                 rc = sscanf(blobmsg_data(cur), "%" PRIu32 ":%" PRIu32, &qos_mapping->from, &qos_mapping->to);
 268                 if (rc != 2) {
 269                         free(qos_mapping);
 270                         continue;
 271                 }
 272                 vlist_simple_add(qos_mapping_li, &qos_mapping->node);
 273         }
 274 }
 275
 276 static void
 277 vlandev_apply_settings(struct vlandev_device *mvdev, struct blob_attr **tb)
 278 {
 279         struct vlandev_config *cfg = &mvdev->config;
 280         struct blob_attr *cur;
 281
 282         cfg->proto = (mvdev->dev.type == &vlan8021q_device_type) ?
 283                 VLAN_PROTO_8021Q : VLAN_PROTO_8021AD;
 284         cfg->vid = 1;
 285
 286         vlist_simple_update(&cfg->ingress_qos_mapping_list);
 287         vlist_simple_update(&cfg->egress_qos_mapping_list);
 288
 289         if ((cur = tb[VLANDEV_ATTR_VID]))
 290                 cfg->vid = (uint16_t) blobmsg_get_u32(cur);
 291
 292         if ((cur = tb[VLANDEV_ATTR_INGRESS_QOS_MAPPING]))
 293                 vlandev_qos_mapping_list_apply(&cfg->ingress_qos_mapping_list, cur);
 294
 295         if ((cur = tb[VLANDEV_ATTR_EGRESS_QOS_MAPPING]))
 296                 vlandev_qos_mapping_list_apply(&cfg->egress_qos_mapping_list, cur);
 297
 298         vlist_simple_flush(&cfg->ingress_qos_mapping_list);
 299         vlist_simple_flush(&cfg->egress_qos_mapping_list);
 300 }
 301
 302 static enum dev_change_type
 303 vlandev_reload(struct device *dev, struct blob_attr *attr)
 304 {
 305         struct blob_attr *tb_dev[__DEV_ATTR_MAX];
 306         struct blob_attr *tb_mv[__VLANDEV_ATTR_MAX];
 307         enum dev_change_type ret = DEV_CONFIG_APPLIED;
 308         struct vlandev_device *mvdev;
 309
 310         mvdev = container_of(dev, struct vlandev_device, dev);
 311         attr = blob_memdup(attr);
 312
 313         blobmsg_parse(device_attr_list.params, __DEV_ATTR_MAX, tb_dev,
 314                 blob_data(attr), blob_len(attr));
 315         blobmsg_parse(vlandev_attrs, __VLANDEV_ATTR_MAX, tb_mv,
 316                 blob_data(attr), blob_len(attr));
 317
 318         device_init_settings(dev, tb_dev);
 319         vlandev_apply_settings(mvdev, tb_mv);
 320         mvdev->ifname = tb_mv[VLANDEV_ATTR_IFNAME];
 321
 322         if (mvdev->config_data) {
 323                 struct blob_attr *otb_dev[__DEV_ATTR_MAX];
 324                 struct blob_attr *otb_mv[__VLANDEV_ATTR_MAX];
 325
 326                 blobmsg_parse(device_attr_list.params, __DEV_ATTR_MAX, otb_dev,
 327                         blob_data(mvdev->config_data), blob_len(mvdev->config_data));
 328
 329                 if (uci_blob_diff(tb_dev, otb_dev, &device_attr_list, NULL))
 330                     ret = DEV_CONFIG_RESTART;
 331
 332                 blobmsg_parse(vlandev_attrs, __VLANDEV_ATTR_MAX, otb_mv,
 333                         blob_data(mvdev->config_data), blob_len(mvdev->config_data));
 334
 335                 if (uci_blob_diff(tb_mv, otb_mv, &vlandev_attr_list, NULL))
 336                     ret = DEV_CONFIG_RESTART;
 337
 338                 vlandev_config_init(dev);
 339         }
 340
 341         free(mvdev->config_data);
 342         mvdev->config_data = attr;
 343         return ret;
 344 }
 345
 346 static struct device *
 347 vlandev_create(const char *name, struct device_type *devtype,
 348                struct blob_attr *attr)
 349 {
 350         struct vlandev_device *mvdev;
 351         struct device *dev = NULL;
 352
 353         mvdev = calloc(1, sizeof(*mvdev));
 354         if (!mvdev)
 355                 return NULL;
 356
 357         vlist_simple_init(&mvdev->config.ingress_qos_mapping_list,
 358                           struct vlan_qos_mapping, node);
 359         vlist_simple_init(&mvdev->config.egress_qos_mapping_list,
 360                           struct vlan_qos_mapping, node);
 361
 362         dev = &mvdev->dev;
 363
 364         if (device_init(dev, devtype, name) < 0) {
 365                 device_cleanup(dev);
 366                 free(mvdev);
 367                 return NULL;
 368         }
 369
 370         dev->config_pending = true;
 371
 372         mvdev->set_state = dev->set_state;
 373         dev->set_state = vlandev_set_state;
 374
 375         dev->hotplug_ops = NULL;
 376         mvdev->parent.cb = vlandev_base_cb;
 377
 378         vlandev_reload(dev, attr);
 379
 380         return dev;
 381 }
 382
 383 static struct device_type vlan8021ad_device_type = {
 384         .name = "8021ad",
 385         .config_params = &vlandev_attr_list,
 386         .create = vlandev_create,
 387         .config_init = vlandev_config_init,
 388         .reload = vlandev_reload,
 389         .free = vlandev_free,
 390         .dump_info = vlandev_dump_info,
 391 };
 392
 393 static struct device_type vlan8021q_device_type = {
 394         .name = "8021q",
 395         .config_params = &vlandev_attr_list,
 396         .create = vlandev_create,
 397         .config_init = vlandev_config_init,
 398         .reload = vlandev_reload,
 399         .free = vlandev_free,
 400         .dump_info = vlandev_dump_info,
 401 };
 402
 403 static void __init vlandev_device_type_init(void)
 404 {
 405         device_type_add(&vlan8021ad_device_type);
 406         device_type_add(&vlan8021q_device_type);
 407 }