1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
|
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <libubox/uapi.h>
#include "netifd.h"
#include "system.h"
static struct avl_tree devices;
static int avl_strcmp(const void *k1, const void *k2, void *ptr)
{
return strcmp(k1, k2);
}
static void API_CTOR dev_init(void)
{
avl_init(&devices, avl_strcmp, false, NULL);
}
static void free_simple_device(struct device *dev)
{
cleanup_device(dev);
free(dev);
}
static void broadcast_device_event(struct device *dev, enum device_event ev)
{
struct device_user *dep, *tmp;
list_for_each_entry_safe(dep, tmp, &dev->users, list) {
if (!dep->cb)
continue;
dep->cb(dep, ev);
}
}
static int set_device_state(struct device *dev, bool state)
{
if (state)
system_if_up(dev);
else
system_if_down(dev);
return 0;
}
int claim_device(struct device *dev)
{
int ret;
DPRINTF("claim device %s, new refcount: %d\n", dev->ifname, dev->active + 1);
if (++dev->active != 1)
return 0;
broadcast_device_event(dev, DEV_EVENT_SETUP);
ret = dev->set_state(dev, true);
if (ret == 0)
broadcast_device_event(dev, DEV_EVENT_UP);
else
dev->active = 0;
return ret;
}
void release_device(struct device *dev)
{
dev->active--;
DPRINTF("release device %s, new refcount: %d\n", dev->ifname, dev->active);
assert(dev->active >= 0);
if (dev->active)
return;
broadcast_device_event(dev, DEV_EVENT_TEARDOWN);
dev->set_state(dev, false);
broadcast_device_event(dev, DEV_EVENT_DOWN);
}
int check_device_state(struct device *dev)
{
if (!dev->type->check_state)
return 0;
return dev->type->check_state(dev);
}
void init_virtual_device(struct device *dev, const struct device_type *type, const char *name)
{
assert(dev);
assert(type);
if (name)
strncpy(dev->ifname, name, IFNAMSIZ);
fprintf(stderr, "Initialize device '%s'\n", dev->ifname);
INIT_LIST_HEAD(&dev->users);
dev->type = type;
}
int init_device(struct device *dev, const struct device_type *type, const char *ifname)
{
int ret;
init_virtual_device(dev, type, ifname);
if (!dev->set_state)
dev->set_state = set_device_state;
dev->avl.key = dev->ifname;
ret = avl_insert(&devices, &dev->avl);
if (ret < 0)
return ret;
check_device_state(dev);
return 0;
}
struct device *get_device(const char *name, bool create)
{
static const struct device_type simple_type = {
.name = "Device",
.check_state = system_if_check,
.free = free_simple_device,
};
struct device *dev;
if (strchr(name, '.'))
return get_vlan_device_chain(name, create);
dev = avl_find_element(&devices, name, dev, avl);
if (dev)
return dev;
if (!create)
return NULL;
dev = calloc(1, sizeof(*dev));
init_device(dev, &simple_type, name);
return dev;
}
void cleanup_device(struct device *dev)
{
struct device_user *dep, *tmp;
fprintf(stderr, "Clean up device '%s'\n", dev->ifname);
list_for_each_entry_safe(dep, tmp, &dev->users, list) {
if (!dep->cb)
continue;
dep->cb(dep, DEV_EVENT_REMOVE);
}
if (dev->avl.key)
avl_delete(&devices, &dev->avl);
}
void set_device_present(struct device *dev, bool state)
{
if (dev->present == state)
return;
DPRINTF("Device '%s' %s present\n", dev->ifname, state ? "is now" : "is no longer" );
dev->present = state;
broadcast_device_event(dev, state ? DEV_EVENT_ADD : DEV_EVENT_REMOVE);
}
void add_device_user(struct device_user *dep, struct device *dev)
{
dep->dev = dev;
list_add(&dep->list, &dev->users);
if (dep->cb && dev->present) {
dep->cb(dep, DEV_EVENT_ADD);
if (dev->active)
dep->cb(dep, DEV_EVENT_UP);
}
}
void remove_device_user(struct device_user *dep)
{
struct device *dev = dep->dev;
list_del(&dep->list);
if (list_empty(&dev->users)) {
/* all references have gone away, remove this device */
free_device(dev);
}
dep->dev = NULL;
}
void
cleanup_devices(void)
{
struct device *dev, *tmp;
avl_for_each_element_safe(&devices, dev, avl, tmp) {
if (!list_empty(&dev->users))
continue;
free_device(dev);
}
}
|
