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 *dev)
 124 {
 125         int ret;
 126
 127         DPRINTF("claim device %s, new refcount: %d\n", dev->ifname, dev->active + 1);
 128         if (++dev->active != 1)
 129                 return 0;
 130
 131         device_broadcast_event(dev, DEV_EVENT_SETUP);
 132         ret = dev->set_state(dev, true);
 133         if (ret == 0)
 134                 device_broadcast_event(dev, DEV_EVENT_UP);
 135         else
 136                 dev->active = 0;
 137
 138         return ret;
 139 }
 140
 141 void device_release(struct device *dev)
 142 {
 143         dev->active--;
 144         DPRINTF("release device %s, new refcount: %d\n", dev->ifname, dev->active);
 145         assert(dev->active >= 0);
 146
 147         if (dev->active)
 148                 return;
 149
 150         device_broadcast_event(dev, DEV_EVENT_TEARDOWN);
 151         dev->set_state(dev, false);
 152         device_broadcast_event(dev, DEV_EVENT_DOWN);
 153 }
 154
 155 int check_device_state(struct device *dev)
 156 {
 157         if (!dev->type->check_state)
 158                 return 0;
 159
 160         return dev->type->check_state(dev);
 161 }
 162
 163 void device_init_virtual(struct device *dev, const struct device_type *type, const char *name)
 164 {
 165         assert(dev);
 166         assert(type);
 167
 168         if (name)
 169                 strncpy(dev->ifname, name, IFNAMSIZ);
 170
 171         fprintf(stderr, "Initialize device '%s'\n", dev->ifname);
 172         INIT_LIST_HEAD(&dev->users);
 173         dev->type = type;
 174 }
 175
 176 int device_init(struct device *dev, const struct device_type *type, const char *ifname)
 177 {
 178         int ret;
 179
 180         device_init_virtual(dev, type, ifname);
 181
 182         if (!dev->set_state)
 183                 dev->set_state = set_device_state;
 184
 185         dev->avl.key = dev->ifname;
 186
 187         ret = avl_insert(&devices, &dev->avl);
 188         if (ret < 0)
 189                 return ret;
 190
 191         check_device_state(dev);
 192
 193         return 0;
 194 }
 195
 196 struct device *device_get(const char *name, bool create)
 197 {
 198         struct device *dev;
 199
 200         if (strchr(name, '.'))
 201                 return get_vlan_device_chain(name, create);
 202
 203         dev = avl_find_element(&devices, name, dev, avl);
 204         if (dev)
 205                 return dev;
 206
 207         if (!create)
 208                 return NULL;
 209
 210         dev = calloc(1, sizeof(*dev));
 211         device_init(dev, &simple_device_type, name);
 212
 213         return dev;
 214 }
 215
 216 void device_cleanup(struct device *dev)
 217 {
 218         struct device_user *dep, *tmp;
 219
 220         fprintf(stderr, "Clean up device '%s'\n", dev->ifname);
 221         list_for_each_entry_safe(dep, tmp, &dev->users, list) {
 222                 if (!dep->cb)
 223                         continue;
 224
 225                 dep->cb(dep, DEV_EVENT_REMOVE);
 226         }
 227
 228         if (dev->avl.key)
 229                 avl_delete(&devices, &dev->avl);
 230 }
 231
 232 void device_set_present(struct device *dev, bool state)
 233 {
 234         if (dev->present == state)
 235                 return;
 236
 237         DPRINTF("Device '%s' %s present\n", dev->ifname, state ? "is now" : "is no longer" );
 238         dev->present = state;
 239         device_broadcast_event(dev, state ? DEV_EVENT_ADD : DEV_EVENT_REMOVE);
 240 }
 241
 242 void device_add_user(struct device_user *dep, struct device *dev)
 243 {
 244         dep->dev = dev;
 245         list_add(&dep->list, &dev->users);
 246         if (dep->cb && dev->present) {
 247                 dep->cb(dep, DEV_EVENT_ADD);
 248                 if (dev->active)
 249                         dep->cb(dep, DEV_EVENT_UP);
 250         }
 251 }
 252
 253 void device_remove_user(struct device_user *dep)
 254 {
 255         struct device *dev = dep->dev;
 256
 257         list_del(&dep->list);
 258
 259         if (list_empty(&dev->users)) {
 260                 /* all references have gone away, remove this device */
 261                 device_free(dev);
 262         }
 263
 264         dep->dev = NULL;
 265 }
 266
 267 void
 268 device_free_all(void)
 269 {
 270         struct device *dev, *tmp;
 271
 272         avl_for_each_element_safe(&devices, dev, avl, tmp) {
 273                 if (!list_empty(&dev->users))
 274                         continue;
 275
 276                 device_free(dev);
 277         }
 278 }