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