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 } 445
This page was automatically generated by LXR 0.3.1. • OpenWrt