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