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