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