Add inline fls() function for linux
[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 #include "netifd.h"
11 #include "system.h"
12 #include "config.h"
13
14 static struct avl_tree devices;
15
16 static const struct blobmsg_policy dev_attrs[__DEV_ATTR_MAX] = {
17         [DEV_ATTR_TYPE] = { "type", BLOBMSG_TYPE_STRING },
18         [DEV_ATTR_NAME] = { "name", BLOBMSG_TYPE_STRING },
19         [DEV_ATTR_IFNAME] = { "ifname", BLOBMSG_TYPE_ARRAY },
20         [DEV_ATTR_MTU] = { "mtu", BLOBMSG_TYPE_INT32 },
21         [DEV_ATTR_MACADDR] = { "macaddr", BLOBMSG_TYPE_STRING },
22         [DEV_ATTR_TXQUEUELEN] = { "txqueuelen", BLOBMSG_TYPE_INT32 },
23 };
24
25 const struct config_param_list device_attr_list = {
26         .n_params = __DEV_ATTR_MAX,
27         .params = dev_attrs,
28 };
29
30 static struct device *
31 simple_device_create(struct blob_attr *attr)
32 {
33         struct blob_attr *tb[__DEV_ATTR_MAX];
34         struct device *dev = NULL;
35         const char *name;
36
37         blobmsg_parse(dev_attrs, __DEV_ATTR_MAX, tb, blob_data(attr), blob_len(attr));
38         if (!tb[DEV_ATTR_NAME])
39                 return NULL;
40
41         name = blobmsg_data(tb[DEV_ATTR_NAME]);
42         if (!name)
43                 return NULL;
44
45         dev = device_get(name, true);
46         if (!dev)
47                 return NULL;
48
49         device_init_settings(dev, tb);
50
51         return dev;
52 }
53
54 static void simple_device_free(struct device *dev)
55 {
56         device_cleanup(dev);
57         free(dev);
58 }
59
60 const struct device_type simple_device_type = {
61         .name = "Network device",
62         .config_params = &device_attr_list,
63
64         .create = simple_device_create,
65         .check_state = system_if_check,
66         .free = simple_device_free,
67 };
68
69 void
70 device_init_settings(struct device *dev, struct blob_attr **tb)
71 {
72         struct blob_attr *cur;
73         struct ether_addr *ea;
74
75         dev->flags = 0;
76
77         if ((cur = tb[DEV_ATTR_MTU])) {
78                 dev->mtu = blobmsg_get_u32(cur);
79                 dev->flags |= DEV_OPT_MTU;
80         }
81
82         if ((cur = tb[DEV_ATTR_TXQUEUELEN])) {
83                 dev->txqueuelen = blobmsg_get_u32(cur);
84                 dev->flags |= DEV_OPT_TXQUEUELEN;
85         }
86
87         if ((cur = tb[DEV_ATTR_MACADDR])) {
88                 ea = ether_aton(blob_data(cur));
89                 if (ea) {
90                         memcpy(dev->macaddr, ea, sizeof(dev->macaddr));
91                         dev->flags |= DEV_OPT_MACADDR;
92                 }
93         }
94 }
95
96 static void __init dev_init(void)
97 {
98         avl_init(&devices, avl_strcmp, false, NULL);
99 }
100
101 static void device_broadcast_event(struct device *dev, enum device_event ev)
102 {
103         struct device_user *dep, *tmp;
104
105         list_for_each_entry_safe(dep, tmp, &dev->users, list) {
106                 if (!dep->cb)
107                         continue;
108
109                 dep->cb(dep, ev);
110         }
111 }
112
113 static int set_device_state(struct device *dev, bool state)
114 {
115         if (state)
116                 system_if_up(dev);
117         else
118                 system_if_down(dev);
119
120         return 0;
121 }
122
123 int device_claim(struct device_user *dep)
124 {
125         struct device *dev = dep->dev;
126         int ret;
127
128         if (dep->claimed)
129                 return 0;
130
131         dep->claimed = true;
132         DPRINTF("claim device %s, new refcount: %d\n", dev->ifname, dev->active + 1);
133         if (++dev->active != 1)
134                 return 0;
135
136         device_broadcast_event(dev, DEV_EVENT_SETUP);
137         ret = dev->set_state(dev, true);
138         if (ret == 0)
139                 device_broadcast_event(dev, DEV_EVENT_UP);
140         else
141                 dev->active = 0;
142
143         return ret;
144 }
145
146 void device_release(struct device_user *dep)
147 {
148         struct device *dev = dep->dev;
149
150         if (!dep->claimed)
151                 return;
152
153         dep->claimed = false;
154         dev->active--;
155         DPRINTF("release device %s, new refcount: %d\n", dev->ifname, dev->active);
156         assert(dev->active >= 0);
157
158         if (dev->active)
159                 return;
160
161         device_broadcast_event(dev, DEV_EVENT_TEARDOWN);
162         dev->set_state(dev, false);
163         device_broadcast_event(dev, DEV_EVENT_DOWN);
164 }
165
166 int check_device_state(struct device *dev)
167 {
168         if (!dev->type->check_state)
169                 return 0;
170
171         return dev->type->check_state(dev);
172 }
173
174 void device_init_virtual(struct device *dev, const struct device_type *type, const char *name)
175 {
176         assert(dev);
177         assert(type);
178
179         if (name)
180                 strncpy(dev->ifname, name, IFNAMSIZ);
181
182         fprintf(stderr, "Initialize device '%s'\n", dev->ifname);
183         INIT_LIST_HEAD(&dev->users);
184         dev->type = type;
185 }
186
187 int device_init(struct device *dev, const struct device_type *type, const char *ifname)
188 {
189         int ret;
190
191         device_init_virtual(dev, type, ifname);
192
193         if (!dev->set_state)
194                 dev->set_state = set_device_state;
195
196         dev->avl.key = dev->ifname;
197
198         ret = avl_insert(&devices, &dev->avl);
199         if (ret < 0)
200                 return ret;
201
202         check_device_state(dev);
203
204         return 0;
205 }
206
207 struct device *device_get(const char *name, bool create)
208 {
209         struct device *dev;
210
211         if (strchr(name, '.'))
212                 return get_vlan_device_chain(name, create);
213
214         dev = avl_find_element(&devices, name, dev, avl);
215         if (dev)
216                 return dev;
217
218         if (!create)
219                 return NULL;
220
221         dev = calloc(1, sizeof(*dev));
222         device_init(dev, &simple_device_type, name);
223
224         return dev;
225 }
226
227 void device_cleanup(struct device *dev)
228 {
229         struct device_user *dep, *tmp;
230
231         fprintf(stderr, "Clean up device '%s'\n", dev->ifname);
232         list_for_each_entry_safe(dep, tmp, &dev->users, list) {
233                 if (!dep->cb)
234                         continue;
235
236                 dep->cb(dep, DEV_EVENT_REMOVE);
237         }
238
239         if (dev->avl.key)
240                 avl_delete(&devices, &dev->avl);
241 }
242
243 void device_set_present(struct device *dev, bool state)
244 {
245         if (dev->present == state)
246                 return;
247
248         DPRINTF("Device '%s' %s present\n", dev->ifname, state ? "is now" : "is no longer" );
249         dev->present = state;
250         device_broadcast_event(dev, state ? DEV_EVENT_ADD : DEV_EVENT_REMOVE);
251 }
252
253 void device_add_user(struct device_user *dep, struct device *dev)
254 {
255         dep->dev = dev;
256         list_add_tail(&dep->list, &dev->users);
257         if (dep->cb && dev->present) {
258                 dep->cb(dep, DEV_EVENT_ADD);
259                 if (dev->active)
260                         dep->cb(dep, DEV_EVENT_UP);
261         }
262 }
263
264 static void
265 __device_free_unused(struct device *dev)
266 {
267         if (!list_empty(&dev->users))
268                 return;
269
270         device_free(dev);
271 }
272
273 void device_remove_user(struct device_user *dep)
274 {
275         struct device *dev = dep->dev;
276
277         if (dep->claimed)
278                 device_release(dep);
279
280         list_del(&dep->list);
281         dep->dev = NULL;
282         __device_free_unused(dev);
283 }
284
285 void
286 device_free_unused(struct device *dev)
287 {
288         struct device *tmp;
289
290         if (dev)
291                 return __device_free_unused(dev);
292
293         avl_for_each_element_safe(&devices, dev, avl, tmp)
294                 __device_free_unused(dev);
295 }