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