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)
 312 {
 313         struct device *dev;
 314
 315         D(DEVICE, "Create simple device '%s'\n", name);
 316         dev = calloc(1, sizeof(*dev));
 317         device_init(dev, &simple_device_type, name);
 318         dev->default_config = true;
 319         return dev;
 320 }
 321
 322 static struct device *
 323 device_alias_get(const char *name)
 324 {
 325         struct alias_device *alias;
 326
 327         alias = avl_find_element(&aliases, name, alias, avl);
 328         if (alias)
 329                 return &alias->dev;
 330
 331         return alias_device_create(name, NULL);
 332 }
 333
 334 struct device *
 335 device_get(const char *name, bool create)
 336 {
 337         struct device *dev;
 338
 339         if (strchr(name, '.'))
 340                 return get_vlan_device_chain(name, create);
 341
 342         if (name[0] == '@')
 343                 return device_alias_get(name + 1);
 344
 345         dev = avl_find_element(&devices, name, dev, avl);
 346         if (dev)
 347                 return dev;
 348
 349         if (!create)
 350                 return NULL;
 351
 352         return device_create_default(name);
 353 }
 354
 355 static void
 356 device_delete(struct device *dev)
 357 {
 358         if (!dev->avl.key)
 359                 return;
 360
 361         D(DEVICE, "Delete device '%s' from list\n", dev->ifname);
 362         avl_delete(&devices, &dev->avl);
 363         dev->avl.key = NULL;
 364 }
 365
 366 void device_cleanup(struct device *dev)
 367 {
 368         struct device_user *dep, *tmp;
 369
 370         D(DEVICE, "Clean up device '%s'\n", dev->ifname);
 371         list_for_each_entry_safe(dep, tmp, &dev->users, list) {
 372                 if (!dep->cb)
 373                         continue;
 374
 375                 dep->cb(dep, DEV_EVENT_REMOVE);
 376                 device_release(dep);
 377         }
 378
 379         device_delete(dev);
 380 }
 381
 382 void device_set_present(struct device *dev, bool state)
 383 {
 384         if (dev->present == state)
 385                 return;
 386
 387         D(DEVICE, "%s '%s' %s present\n", dev->type->name, dev->ifname, state ? "is now" : "is no longer" );
 388         dev->present = state;
 389         device_broadcast_event(dev, state ? DEV_EVENT_ADD : DEV_EVENT_REMOVE);
 390 }
 391
 392 void device_add_user(struct device_user *dep, struct device *dev)
 393 {
 394         dep->dev = dev;
 395         list_add_tail(&dep->list, &dev->users);
 396         if (dep->cb && dev->present) {
 397                 dep->cb(dep, DEV_EVENT_ADD);
 398                 if (dev->active)
 399                         dep->cb(dep, DEV_EVENT_UP);
 400         }
 401 }
 402
 403 static void
 404 __device_free_unused(struct device *dev)
 405 {
 406         if (!list_empty(&dev->users) || dev->current_config || __devlock)
 407                 return;
 408
 409         device_free(dev);
 410 }
 411
 412 void device_remove_user(struct device_user *dep)
 413 {
 414         struct device *dev = dep->dev;
 415
 416         if (!dep->dev)
 417                 return;
 418
 419         dep->hotplug = false;
 420         if (dep->claimed)
 421                 device_release(dep);
 422
 423         list_del(&dep->list);
 424         dep->dev = NULL;
 425         __device_free_unused(dev);
 426 }
 427
 428 void
 429 device_free_unused(struct device *dev)
 430 {
 431         struct device *tmp;
 432
 433         if (dev)
 434                 return __device_free_unused(dev);
 435
 436         avl_for_each_element_safe(&devices, dev, avl, tmp)
 437                 __device_free_unused(dev);
 438 }
 439
 440 void
 441 device_init_pending(void)
 442 {
 443         struct device *dev, *tmp;
 444
 445         avl_for_each_element_safe(&devices, dev, avl, tmp) {
 446                 if (!dev->config_pending)
 447                         continue;
 448
 449                 dev->type->config_init(dev);
 450                 dev->config_pending = false;
 451         }
 452 }
 453
 454 static enum dev_change_type
 455 device_reload_config(struct device *dev, struct blob_attr *attr)
 456 {
 457         struct blob_attr *tb[__DEV_ATTR_MAX];
 458         const struct config_param_list *cfg = dev->type->config_params;
 459
 460         if (config_check_equal(dev->config, attr, cfg))
 461                 return DEV_CONFIG_NO_CHANGE;
 462
 463         if (cfg == &device_attr_list) {
 464                 memset(tb, 0, sizeof(tb));
 465
 466                 if (attr)
 467                         blobmsg_parse(dev_attrs, __DEV_ATTR_MAX, tb,
 468                                 blob_data(attr), blob_len(attr));
 469
 470                 device_init_settings(dev, tb);
 471                 return DEV_CONFIG_APPLIED;
 472         } else
 473                 return DEV_CONFIG_RECREATE;
 474 }
 475
 476 enum dev_change_type
 477 device_set_config(struct device *dev, const struct device_type *type,
 478                   struct blob_attr *attr)
 479 {
 480         if (type != dev->type)
 481                 return DEV_CONFIG_RECREATE;
 482
 483         if (dev->type->reload)
 484                 return dev->type->reload(dev, attr);
 485
 486         return device_reload_config(dev, attr);
 487 }
 488
 489 static void
 490 device_replace(struct device *dev, struct device *odev)
 491 {
 492         struct device_user *dep, *tmp;
 493         bool present = odev->present;
 494
 495         if (present)
 496                 device_set_present(odev, false);
 497
 498         list_for_each_entry_safe(dep, tmp, &odev->users, list) {
 499                 device_release(dep);
 500                 list_move_tail(&dep->list, &dev->users);
 501                 dep->dev = dev;
 502         }
 503         device_free(odev);
 504
 505         if (present)
 506                 device_set_present(dev, true);
 507 }
 508
 509 void
 510 device_reset_config(void)
 511 {
 512         struct device *dev;
 513
 514         avl_for_each_element(&devices, dev, avl)
 515                 dev->current_config = false;
 516 }
 517
 518 void
 519 device_reset_old(void)
 520 {
 521         struct device *dev, *tmp, *ndev;
 522
 523         avl_for_each_element_safe(&devices, dev, avl, tmp) {
 524                 if (dev->current_config || dev->default_config)
 525                         continue;
 526
 527                 if (dev->type != &simple_device_type)
 528                         continue;
 529
 530                 ndev = device_create_default(dev->ifname);
 531                 device_replace(ndev, dev);
 532         }
 533 }
 534
 535 struct device *
 536 device_create(const char *name, const struct device_type *type,
 537               struct blob_attr *config)
 538 {
 539         struct device *odev = NULL, *dev;
 540         enum dev_change_type change;
 541
 542         config = config_memdup(config);
 543         if (!config)
 544                 return NULL;
 545
 546         odev = device_get(name, false);
 547         if (odev) {
 548                 odev->current_config = true;
 549                 change = device_set_config(odev, type, config);
 550                 switch (change) {
 551                 case DEV_CONFIG_APPLIED:
 552                         D(DEVICE, "Device '%s': config applied\n", odev->ifname);
 553                         free(odev->config);
 554                         odev->config = config;
 555                         if (odev->present) {
 556                                 device_set_present(odev, false);
 557                                 device_set_present(odev, true);
 558                         }
 559                         return odev;
 560                 case DEV_CONFIG_NO_CHANGE:
 561                         D(DEVICE, "Device '%s': no configuration change\n", odev->ifname);
 562                         free(config);
 563                         return odev;
 564                 case DEV_CONFIG_RECREATE:
 565                         D(DEVICE, "Device '%s': recreate device\n", odev->ifname);
 566                         device_delete(odev);
 567                         break;
 568                 }
 569         } else
 570                 D(DEVICE, "Create new device '%s' (%s)\n", name, type->name);
 571
 572         dev = type->create(name, config);
 573         if (!dev)
 574                 return NULL;
 575
 576         dev->current_config = true;
 577         dev->config = config;
 578         if (odev)
 579                 device_replace(dev, odev);
 580
 581         if (!config_init && dev->config_pending)
 582                 type->config_init(dev);
 583
 584         return dev;
 585 }
 586
 587 void
 588 device_dump_status(struct blob_buf *b, struct device *dev)
 589 {
 590         void *c, *s;
 591
 592         if (!dev) {
 593                 avl_for_each_element(&devices, dev, avl) {
 594                         if (!dev->present)
 595                                 continue;
 596                         c = blobmsg_open_table(b, dev->ifname);
 597                         device_dump_status(b, dev);
 598                         blobmsg_close_table(b, c);
 599                 }
 600
 601                 return;
 602         }
 603
 604         if (!dev->present)
 605                 return;
 606
 607         blobmsg_add_string(b, "type", dev->type->name);
 608         blobmsg_add_u8(b, "up", !!dev->active);
 609         if (dev->type->dump_info)
 610                 dev->type->dump_info(dev, b);
 611
 612         s = blobmsg_open_table(b, "statistics");
 613         if (dev->type->dump_stats)
 614                 dev->type->dump_stats(dev, b);
 615         else
 616                 system_if_dump_stats(dev, b);
 617         blobmsg_close_table(b, s);
 618 }