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