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