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 }