device.c

   1 #include <string.h>
   2 #include <stdlib.h>
   3 #include <stdio.h>
   4 #include <assert.h>
   5
   6 #include <sys/types.h>
   7 #include <sys/socket.h>
   8 #include <net/ethernet.h>
   9
  10 #ifdef linux
  11 #include <netinet/ether.h>
  12 #endif
  13
  14 #include "netifd.h"
  15 #include "system.h"
  16 #include "config.h"
  17
  18 static struct avl_tree devices;
  19 static struct avl_tree aliases;
  20
  21 struct alias_device {
  22         struct avl_node avl;
  23         struct device dev;
  24         struct device_user dep;
  25         bool cleanup;
  26         char name[];
  27 };
  28
  29 static const struct device_type alias_device_type;
  30
  31 static const struct blobmsg_policy dev_attrs[__DEV_ATTR_MAX] = {
  32         [DEV_ATTR_TYPE] = { "type", BLOBMSG_TYPE_STRING },
  33         [DEV_ATTR_IFNAME] = { "ifname", BLOBMSG_TYPE_ARRAY },
  34         [DEV_ATTR_MTU] = { "mtu", BLOBMSG_TYPE_INT32 },
  35         [DEV_ATTR_MACADDR] = { "macaddr", BLOBMSG_TYPE_STRING },
  36         [DEV_ATTR_TXQUEUELEN] = { "txqueuelen", BLOBMSG_TYPE_INT32 },
  37 };
  38
  39 const struct config_param_list device_attr_list = {
  40         .n_params = __DEV_ATTR_MAX,
  41         .params = dev_attrs,
  42 };
  43
  44 static struct device *
  45 simple_device_create(const char *name, struct blob_attr *attr)
  46 {
  47         struct blob_attr *tb[__DEV_ATTR_MAX];
  48         struct device *dev = NULL;
  49
  50         blobmsg_parse(dev_attrs, __DEV_ATTR_MAX, tb, blob_data(attr), blob_len(attr));
  51         dev = device_get(name, true);
  52         if (!dev)
  53                 return NULL;
  54
  55         device_init_settings(dev, tb);
  56
  57         return dev;
  58 }
  59
  60 static void simple_device_free(struct device *dev)
  61 {
  62         device_cleanup(dev);
  63         free(dev);
  64 }
  65
  66 const struct device_type simple_device_type = {
  67         .name = "Network device",
  68         .config_params = &device_attr_list,
  69
  70         .create = simple_device_create,
  71         .check_state = system_if_check,
  72         .free = simple_device_free,
  73 };
  74
  75 static int
  76 alias_device_set_state(struct device *dev, bool state)
  77 {
  78         struct alias_device *alias;
  79
  80         alias = container_of(dev, struct alias_device, dev);
  81         if (!alias->dep.dev)
  82                 return -1;
  83
  84         if (state)
  85                 return device_claim(&alias->dep);
  86
  87         device_release(&alias->dep);
  88         if (alias->cleanup)
  89                 device_remove_user(&alias->dep);
  90         return 0;
  91 }
  92
  93 static struct device *
  94 alias_device_create(const char *name, struct blob_attr *attr)
  95 {
  96         struct alias_device *alias;
  97
  98         alias = calloc(1, sizeof(*alias) + strlen(name) + 1);
  99         strcpy(alias->name, name);
 100         alias->dev.set_state = alias_device_set_state;
 101         device_init_virtual(&alias->dev, &alias_device_type, NULL);
 102         alias->avl.key = alias->name;
 103         avl_insert(&aliases, &alias->avl);
 104
 105         return &alias->dev;
 106 }
 107
 108 static void alias_device_free(struct device *dev)
 109 {
 110         struct alias_device *alias;
 111
 112         device_cleanup(dev);
 113
 114         alias = container_of(dev, struct alias_device, dev);
 115         avl_delete(&aliases, &alias->avl);
 116         free(alias);
 117 }
 118
 119 static const struct device_type alias_device_type = {
 120         .name = "Network alias",
 121         .create = alias_device_create,
 122         .free = alias_device_free,
 123 };
 124
 125 void
 126 device_init_settings(struct device *dev, struct blob_attr **tb)
 127 {
 128         struct blob_attr *cur;
 129         struct ether_addr *ea;
 130
 131         dev->flags = 0;
 132
 133         if ((cur = tb[DEV_ATTR_MTU])) {
 134                 dev->mtu = blobmsg_get_u32(cur);
 135                 dev->flags |= DEV_OPT_MTU;
 136         }
 137
 138         if ((cur = tb[DEV_ATTR_TXQUEUELEN])) {
 139                 dev->txqueuelen = blobmsg_get_u32(cur);
 140                 dev->flags |= DEV_OPT_TXQUEUELEN;
 141         }
 142
 143         if ((cur = tb[DEV_ATTR_MACADDR])) {
 144                 ea = ether_aton(blob_data(cur));
 145                 if (ea) {
 146                         memcpy(dev->macaddr, ea, sizeof(dev->macaddr));
 147                         dev->flags |= DEV_OPT_MACADDR;
 148                 }
 149         }
 150 }
 151
 152 static void __init dev_init(void)
 153 {
 154         avl_init(&devices, avl_strcmp, true, NULL);
 155         avl_init(&aliases, avl_strcmp, false, NULL);
 156 }
 157
 158 static void device_broadcast_event(struct device *dev, enum device_event ev)
 159 {
 160         struct device_user *dep, *tmp;
 161
 162         list_for_each_entry_safe(dep, tmp, &dev->users, list) {
 163                 if (!dep->cb)
 164                         continue;
 165
 166                 dep->cb(dep, ev);
 167         }
 168 }
 169
 170 void
 171 alias_notify_device(const char *name, struct device *dev)
 172 {
 173         struct alias_device *alias;
 174
 175         alias = avl_find_element(&aliases, name, alias, avl);
 176         if (!alias)
 177                 return;
 178
 179         alias->cleanup = !dev;
 180         if (dev) {
 181                 if (dev != alias->dep.dev) {
 182                         device_remove_user(&alias->dep);
 183                         strcpy(alias->dev.ifname, dev->ifname);
 184                         device_add_user(&alias->dep, dev);
 185                 }
 186         }
 187
 188         device_set_present(&alias->dev, !!dev);
 189
 190         if (!dev && alias->dep.dev && !alias->dep.dev->active)
 191                 device_remove_user(&alias->dep);
 192 }
 193
 194 static int set_device_state(struct device *dev, bool state)
 195 {
 196         if (state)
 197                 system_if_up(dev);
 198         else
 199                 system_if_down(dev);
 200
 201         return 0;
 202 }
 203
 204 int device_claim(struct device_user *dep)
 205 {
 206         struct device *dev = dep->dev;
 207         int ret;
 208
 209         if (dep->claimed)
 210                 return 0;
 211
 212         dep->claimed = true;
 213         D(DEVICE, "Claim %s %s, new refcount: %d\n", dev->type->name, dev->ifname, dev->active + 1);
 214         if (++dev->active != 1)
 215                 return 0;
 216
 217         device_broadcast_event(dev, DEV_EVENT_SETUP);
 218         ret = dev->set_state(dev, true);
 219         if (ret == 0)
 220                 device_broadcast_event(dev, DEV_EVENT_UP);
 221         else {
 222                 D(DEVICE, "claim device %s failed: %d\n", dev->ifname, ret);
 223                 dev->active = 0;
 224                 dep->claimed = false;
 225         }
 226
 227         return ret;
 228 }
 229
 230 void device_release(struct device_user *dep)
 231 {
 232         struct device *dev = dep->dev;
 233
 234         if (!dep->claimed)
 235                 return;
 236
 237         dep->claimed = false;
 238         dev->active--;
 239         D(DEVICE, "Release %s %s, new refcount: %d\n", dev->type->name, dev->ifname, dev->active);
 240         assert(dev->active >= 0);
 241
 242         if (dev->active)
 243                 return;
 244
 245         device_broadcast_event(dev, DEV_EVENT_TEARDOWN);
 246         dev->set_state(dev, false);
 247         device_broadcast_event(dev, DEV_EVENT_DOWN);
 248 }
 249
 250 int device_check_state(struct device *dev)
 251 {
 252         if (!dev->type->check_state)
 253                 return 0;
 254
 255         return dev->type->check_state(dev);
 256 }
 257
 258 void device_init_virtual(struct device *dev, const struct device_type *type, const char *name)
 259 {
 260         assert(dev);
 261         assert(type);
 262
 263         if (name)
 264                 strncpy(dev->ifname, name, IFNAMSIZ);
 265
 266         D(DEVICE, "Initialize device '%s'\n", dev->ifname);
 267         INIT_LIST_HEAD(&dev->users);
 268         dev->type = type;
 269 }
 270
 271 int device_init(struct device *dev, const struct device_type *type, const char *ifname)
 272 {
 273         int ret;
 274
 275         device_init_virtual(dev, type, ifname);
 276
 277         if (!dev->set_state)
 278                 dev->set_state = set_device_state;
 279
 280         dev->avl.key = dev->ifname;
 281
 282         ret = avl_insert(&devices, &dev->avl);
 283         if (ret < 0)
 284                 return ret;
 285
 286         system_if_clear_state(dev);
 287         device_check_state(dev);
 288
 289         return 0;
 290 }
 291
 292 static struct device *
 293 device_create_default(const char *name)
 294 {
 295         struct device *dev;
 296
 297         D(DEVICE, "Create simple device '%s'\n", name);
 298         dev = calloc(1, sizeof(*dev));
 299         device_init(dev, &simple_device_type, name);
 300         dev->default_config = true;
 301         return dev;
 302 }
 303
 304 static struct device *
 305 device_alias_get(const char *name)
 306 {
 307         struct alias_device *alias;
 308
 309         alias = avl_find_element(&aliases, name, alias, avl);
 310         if (alias)
 311                 return &alias->dev;
 312
 313         return alias_device_create(name, NULL);
 314 }
 315
 316 struct device *
 317 device_get(const char *name, bool create)
 318 {
 319         struct device *dev;
 320
 321         if (strchr(name, '.'))
 322                 return get_vlan_device_chain(name, create);
 323
 324         if (name[0] == '@')
 325                 return device_alias_get(name + 1);
 326
 327         dev = avl_find_element(&devices, name, dev, avl);
 328         if (dev)
 329                 return dev;
 330
 331         if (!create)
 332                 return NULL;
 333
 334         return device_create_default(name);
 335 }
 336
 337 static void
 338 device_delete(struct device *dev)
 339 {
 340         if (!dev->avl.key)
 341                 return;
 342
 343         D(DEVICE, "Delete device '%s' from list\n", dev->ifname);
 344         avl_delete(&devices, &dev->avl);
 345         dev->avl.key = NULL;
 346 }
 347
 348 void device_cleanup(struct device *dev)
 349 {
 350         struct device_user *dep, *tmp;
 351
 352         D(DEVICE, "Clean up device '%s'\n", dev->ifname);
 353         list_for_each_entry_safe(dep, tmp, &dev->users, list) {
 354                 if (!dep->cb)
 355                         continue;
 356
 357                 dep->cb(dep, DEV_EVENT_REMOVE);
 358                 device_release(dep);
 359         }
 360
 361         device_delete(dev);
 362 }
 363
 364 void device_set_present(struct device *dev, bool state)
 365 {
 366         if (dev->present == state)
 367                 return;
 368
 369         D(DEVICE, "%s '%s' %s present\n", dev->type->name, dev->ifname, state ? "is now" : "is no longer" );
 370         dev->present = state;
 371         device_broadcast_event(dev, state ? DEV_EVENT_ADD : DEV_EVENT_REMOVE);
 372 }
 373
 374 void device_add_user(struct device_user *dep, struct device *dev)
 375 {
 376         dep->dev = dev;
 377         list_add_tail(&dep->list, &dev->users);
 378         if (dep->cb && dev->present) {
 379                 dep->cb(dep, DEV_EVENT_ADD);
 380                 if (dev->active)
 381                         dep->cb(dep, DEV_EVENT_UP);
 382         }
 383 }
 384
 385 static void
 386 __device_free_unused(struct device *dev)
 387 {
 388         if (!list_empty(&dev->users) || dev->current_config || config_init)
 389                 return;
 390
 391         device_free(dev);
 392 }
 393
 394 void device_remove_user(struct device_user *dep)
 395 {
 396         struct device *dev = dep->dev;
 397
 398         if (!dep->dev)
 399                 return;
 400
 401         if (dep->claimed)
 402                 device_release(dep);
 403
 404         list_del(&dep->list);
 405         dep->dev = NULL;
 406         __device_free_unused(dev);
 407 }
 408
 409 void
 410 device_free_unused(struct device *dev)
 411 {
 412         struct device *tmp;
 413
 414         if (dev)
 415                 return __device_free_unused(dev);
 416
 417         avl_for_each_element_safe(&devices, dev, avl, tmp)
 418                 __device_free_unused(dev);
 419 }
 420
 421 void
 422 device_init_pending(void)
 423 {
 424         struct device *dev, *tmp;
 425
 426         avl_for_each_element_safe(&devices, dev, avl, tmp) {
 427                 if (!dev->config_pending)
 428                         continue;
 429
 430                 dev->type->config_init(dev);
 431                 dev->config_pending = false;
 432         }
 433 }
 434
 435 static enum dev_change_type
 436 device_reload_config(struct device *dev, struct blob_attr *attr)
 437 {
 438         struct blob_attr *tb[__DEV_ATTR_MAX];
 439         const struct config_param_list *cfg = dev->type->config_params;
 440
 441         if (config_check_equal(dev->config, attr, cfg))
 442                 return DEV_CONFIG_NO_CHANGE;
 443
 444         if (cfg == &device_attr_list) {
 445                 memset(tb, 0, sizeof(tb));
 446
 447                 if (attr)
 448                         blobmsg_parse(dev_attrs, __DEV_ATTR_MAX, tb,
 449                                 blob_data(attr), blob_len(attr));
 450
 451                 device_init_settings(dev, tb);
 452                 return DEV_CONFIG_APPLIED;
 453         } else
 454                 return DEV_CONFIG_RECREATE;
 455 }
 456
 457 enum dev_change_type
 458 device_set_config(struct device *dev, const struct device_type *type,
 459                   struct blob_attr *attr)
 460 {
 461         if (type != dev->type)
 462                 return DEV_CONFIG_RECREATE;
 463
 464         if (dev->type->reload)
 465                 return dev->type->reload(dev, attr);
 466
 467         return device_reload_config(dev, attr);
 468 }
 469
 470 static void
 471 device_replace(struct device *dev, struct device *odev)
 472 {
 473         struct device_user *dep, *tmp;
 474         bool present = odev->present;
 475
 476         if (present)
 477                 device_set_present(odev, false);
 478
 479         list_for_each_entry_safe(dep, tmp, &odev->users, list) {
 480                 device_release(dep);
 481                 list_move_tail(&dep->list, &dev->users);
 482                 dep->dev = dev;
 483         }
 484         device_free(odev);
 485
 486         if (present)
 487                 device_set_present(dev, true);
 488 }
 489
 490 void
 491 device_reset_config(void)
 492 {
 493         struct device *dev;
 494
 495         avl_for_each_element(&devices, dev, avl)
 496                 dev->current_config = false;
 497 }
 498
 499 void
 500 device_reset_old(void)
 501 {
 502         struct device *dev, *tmp, *ndev;
 503
 504         avl_for_each_element_safe(&devices, dev, avl, tmp) {
 505                 if (dev->current_config || dev->default_config)
 506                         continue;
 507
 508                 if (dev->type != &simple_device_type)
 509                         continue;
 510
 511                 ndev = device_create_default(dev->ifname);
 512                 device_replace(ndev, dev);
 513         }
 514 }
 515
 516 struct device *
 517 device_create(const char *name, const struct device_type *type,
 518               struct blob_attr *config)
 519 {
 520         struct device *odev = NULL, *dev;
 521         enum dev_change_type change;
 522
 523         config = config_memdup(config);
 524         if (!config)
 525                 return NULL;
 526
 527         odev = device_get(name, false);
 528         if (odev) {
 529                 odev->current_config = true;
 530                 change = device_set_config(odev, type, config);
 531                 switch (change) {
 532                 case DEV_CONFIG_APPLIED:
 533                         D(DEVICE, "Device '%s': config applied\n", odev->ifname);
 534                         free(odev->config);
 535                         odev->config = config;
 536                         if (odev->present) {
 537                                 device_set_present(odev, false);
 538                                 device_set_present(odev, true);
 539                         }
 540                         return odev;
 541                 case DEV_CONFIG_NO_CHANGE:
 542                         D(DEVICE, "Device '%s': no configuration change\n", odev->ifname);
 543                         free(config);
 544                         return odev;
 545                 case DEV_CONFIG_RECREATE:
 546                         D(DEVICE, "Device '%s': recreate device\n", odev->ifname);
 547                         device_delete(odev);
 548                         break;
 549                 }
 550         } else
 551                 D(DEVICE, "Create new device '%s' (%s)\n", name, type->name);
 552
 553         dev = type->create(name, config);
 554         if (!dev)
 555                 return NULL;
 556
 557         dev->current_config = true;
 558         dev->config = config;
 559         if (odev)
 560                 device_replace(dev, odev);
 561
 562         if (!config_init && dev->config_pending)
 563                 type->config_init(dev);
 564
 565         return dev;
 566 }
 567
 568 void
 569 device_dump_status(struct blob_buf *b, struct device *dev)
 570 {
 571         void *c, *s;
 572
 573         if (!dev) {
 574                 avl_for_each_element(&devices, dev, avl) {
 575                         if (!dev->present)
 576                                 continue;
 577                         c = blobmsg_open_table(b, dev->ifname);
 578                         device_dump_status(b, dev);
 579                         blobmsg_close_table(b, c);
 580                 }
 581
 582                 return;
 583         }
 584
 585         if (!dev->present)
 586                 return;
 587
 588         blobmsg_add_string(b, "type", dev->type->name);
 589         blobmsg_add_u8(b, "up", !!dev->active);
 590         if (dev->type->dump_info)
 591                 dev->type->dump_info(dev, b);
 592
 593         s = blobmsg_open_table(b, "statistics");
 594         if (dev->type->dump_stats)
 595                 dev->type->dump_stats(dev, b);
 596         else
 597                 system_if_dump_stats(dev, b);
 598         blobmsg_close_table(b, s);
 599 }