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