net/ieee802154/core.c

   1 /*
   2  * Copyright (C) 2007, 2008, 2009 Siemens AG
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License version 2
   6  * as published by the Free Software Foundation.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  *
  13  */
  14
  15 #include <linux/slab.h>
  16 #include <linux/kernel.h>
  17 #include <linux/module.h>
  18 #include <linux/device.h>
  19
  20 #include <net/cfg802154.h>
  21 #include <net/rtnetlink.h>
  22
  23 #include "ieee802154.h"
  24 #include "nl802154.h"
  25 #include "sysfs.h"
  26 #include "core.h"
  27
  28 /* name for sysfs, %d is appended */
  29 #define PHY_NAME "phy"
  30
  31 /* RCU-protected (and RTNL for writers) */
  32 LIST_HEAD(cfg802154_rdev_list);
  33 int cfg802154_rdev_list_generation;
  34
  35 static int wpan_phy_match(struct device *dev, const void *data)
  36 {
  37         return !strcmp(dev_name(dev), (const char *)data);
  38 }
  39
  40 struct wpan_phy *wpan_phy_find(const char *str)
  41 {
  42         struct device *dev;
  43
  44         if (WARN_ON(!str))
  45                 return NULL;
  46
  47         dev = class_find_device(&wpan_phy_class, NULL, str, wpan_phy_match);
  48         if (!dev)
  49                 return NULL;
  50
  51         return container_of(dev, struct wpan_phy, dev);
  52 }
  53 EXPORT_SYMBOL(wpan_phy_find);
  54
  55 struct wpan_phy_iter_data {
  56         int (*fn)(struct wpan_phy *phy, void *data);
  57         void *data;
  58 };
  59
  60 static int wpan_phy_iter(struct device *dev, void *_data)
  61 {
  62         struct wpan_phy_iter_data *wpid = _data;
  63         struct wpan_phy *phy = container_of(dev, struct wpan_phy, dev);
  64
  65         return wpid->fn(phy, wpid->data);
  66 }
  67
  68 int wpan_phy_for_each(int (*fn)(struct wpan_phy *phy, void *data),
  69                       void *data)
  70 {
  71         struct wpan_phy_iter_data wpid = {
  72                 .fn = fn,
  73                 .data = data,
  74         };
  75
  76         return class_for_each_device(&wpan_phy_class, NULL,
  77                         &wpid, wpan_phy_iter);
  78 }
  79 EXPORT_SYMBOL(wpan_phy_for_each);
  80
  81 struct cfg802154_registered_device *
  82 cfg802154_rdev_by_wpan_phy_idx(int wpan_phy_idx)
  83 {
  84         struct cfg802154_registered_device *result = NULL, *rdev;
  85
  86         ASSERT_RTNL();
  87
  88         list_for_each_entry(rdev, &cfg802154_rdev_list, list) {
  89                 if (rdev->wpan_phy_idx == wpan_phy_idx) {
  90                         result = rdev;
  91                         break;
  92                 }
  93         }
  94
  95         return result;
  96 }
  97
  98 struct wpan_phy *wpan_phy_idx_to_wpan_phy(int wpan_phy_idx)
  99 {
 100         struct cfg802154_registered_device *rdev;
 101
 102         ASSERT_RTNL();
 103
 104         rdev = cfg802154_rdev_by_wpan_phy_idx(wpan_phy_idx);
 105         if (!rdev)
 106                 return NULL;
 107         return &rdev->wpan_phy;
 108 }
 109
 110 struct wpan_phy *
 111 wpan_phy_new(const struct cfg802154_ops *ops, size_t priv_size)
 112 {
 113         static atomic_t wpan_phy_counter = ATOMIC_INIT(0);
 114         struct cfg802154_registered_device *rdev;
 115         size_t alloc_size;
 116
 117         alloc_size = sizeof(*rdev) + priv_size;
 118         rdev = kzalloc(alloc_size, GFP_KERNEL);
 119         if (!rdev)
 120                 return NULL;
 121
 122         rdev->ops = ops;
 123
 124         rdev->wpan_phy_idx = atomic_inc_return(&wpan_phy_counter);
 125
 126         if (unlikely(rdev->wpan_phy_idx < 0)) {
 127                 /* ugh, wrapped! */
 128                 atomic_dec(&wpan_phy_counter);
 129                 kfree(rdev);
 130                 return NULL;
 131         }
 132
 133         /* atomic_inc_return makes it start at 1, make it start at 0 */
 134         rdev->wpan_phy_idx--;
 135
 136         INIT_LIST_HEAD(&rdev->wpan_dev_list);
 137         device_initialize(&rdev->wpan_phy.dev);
 138         dev_set_name(&rdev->wpan_phy.dev, PHY_NAME "%d", rdev->wpan_phy_idx);
 139
 140         rdev->wpan_phy.dev.class = &wpan_phy_class;
 141         rdev->wpan_phy.dev.platform_data = rdev;
 142
 143         wpan_phy_net_set(&rdev->wpan_phy, &init_net);
 144
 145         init_waitqueue_head(&rdev->dev_wait);
 146
 147         return &rdev->wpan_phy;
 148 }
 149 EXPORT_SYMBOL(wpan_phy_new);
 150
 151 int wpan_phy_register(struct wpan_phy *phy)
 152 {
 153         struct cfg802154_registered_device *rdev = wpan_phy_to_rdev(phy);
 154         int ret;
 155
 156         rtnl_lock();
 157         ret = device_add(&phy->dev);
 158         if (ret) {
 159                 rtnl_unlock();
 160                 return ret;
 161         }
 162
 163         list_add_rcu(&rdev->list, &cfg802154_rdev_list);
 164         cfg802154_rdev_list_generation++;
 165
 166         /* TODO phy registered lock */
 167         rtnl_unlock();
 168
 169         /* TODO nl802154 phy notify */
 170
 171         return 0;
 172 }
 173 EXPORT_SYMBOL(wpan_phy_register);
 174
 175 void wpan_phy_unregister(struct wpan_phy *phy)
 176 {
 177         struct cfg802154_registered_device *rdev = wpan_phy_to_rdev(phy);
 178
 179         wait_event(rdev->dev_wait, ({
 180                 int __count;
 181                 rtnl_lock();
 182                 __count = rdev->opencount;
 183                 rtnl_unlock();
 184                 __count == 0; }));
 185
 186         rtnl_lock();
 187         /* TODO nl802154 phy notify */
 188         /* TODO phy registered lock */
 189
 190         WARN_ON(!list_empty(&rdev->wpan_dev_list));
 191
 192         /* First remove the hardware from everywhere, this makes
 193          * it impossible to find from userspace.
 194          */
 195         list_del_rcu(&rdev->list);
 196         synchronize_rcu();
 197
 198         cfg802154_rdev_list_generation++;
 199
 200         device_del(&phy->dev);
 201
 202         rtnl_unlock();
 203 }
 204 EXPORT_SYMBOL(wpan_phy_unregister);
 205
 206 void wpan_phy_free(struct wpan_phy *phy)
 207 {
 208         put_device(&phy->dev);
 209 }
 210 EXPORT_SYMBOL(wpan_phy_free);
 211
 212 int cfg802154_switch_netns(struct cfg802154_registered_device *rdev,
 213                            struct net *net)
 214 {
 215         struct wpan_dev *wpan_dev;
 216         int err = 0;
 217
 218         list_for_each_entry(wpan_dev, &rdev->wpan_dev_list, list) {
 219                 if (!wpan_dev->netdev)
 220                         continue;
 221                 wpan_dev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
 222                 err = dev_change_net_namespace(wpan_dev->netdev, net, "wpan%d");
 223                 if (err)
 224                         break;
 225                 wpan_dev->netdev->features |= NETIF_F_NETNS_LOCAL;
 226         }
 227
 228         if (err) {
 229                 /* failed -- clean up to old netns */
 230                 net = wpan_phy_net(&rdev->wpan_phy);
 231
 232                 list_for_each_entry_continue_reverse(wpan_dev,
 233                                                      &rdev->wpan_dev_list,
 234                                                      list) {
 235                         if (!wpan_dev->netdev)
 236                                 continue;
 237                         wpan_dev->netdev->features &= ~NETIF_F_NETNS_LOCAL;
 238                         err = dev_change_net_namespace(wpan_dev->netdev, net,
 239                                                        "wpan%d");
 240                         WARN_ON(err);
 241                         wpan_dev->netdev->features |= NETIF_F_NETNS_LOCAL;
 242                 }
 243
 244                 return err;
 245         }
 246
 247         wpan_phy_net_set(&rdev->wpan_phy, net);
 248
 249         err = device_rename(&rdev->wpan_phy.dev, dev_name(&rdev->wpan_phy.dev));
 250         WARN_ON(err);
 251
 252         return 0;
 253 }
 254
 255 void cfg802154_dev_free(struct cfg802154_registered_device *rdev)
 256 {
 257         kfree(rdev);
 258 }
 259
 260 static void
 261 cfg802154_update_iface_num(struct cfg802154_registered_device *rdev,
 262                            int iftype, int num)
 263 {
 264         ASSERT_RTNL();
 265
 266         rdev->num_running_ifaces += num;
 267 }
 268
 269 static int cfg802154_netdev_notifier_call(struct notifier_block *nb,
 270                                           unsigned long state, void *ptr)
 271 {
 272         struct net_device *dev = netdev_notifier_info_to_dev(ptr);
 273         struct wpan_dev *wpan_dev = dev->ieee802154_ptr;
 274         struct cfg802154_registered_device *rdev;
 275
 276         if (!wpan_dev)
 277                 return NOTIFY_DONE;
 278
 279         rdev = wpan_phy_to_rdev(wpan_dev->wpan_phy);
 280
 281         /* TODO WARN_ON unspec type */
 282
 283         switch (state) {
 284                 /* TODO NETDEV_DEVTYPE */
 285         case NETDEV_REGISTER:
 286                 dev->features |= NETIF_F_NETNS_LOCAL;
 287                 wpan_dev->identifier = ++rdev->wpan_dev_id;
 288                 list_add_rcu(&wpan_dev->list, &rdev->wpan_dev_list);
 289                 rdev->devlist_generation++;
 290
 291                 wpan_dev->netdev = dev;
 292                 break;
 293         case NETDEV_DOWN:
 294                 cfg802154_update_iface_num(rdev, wpan_dev->iftype, -1);
 295
 296                 rdev->opencount--;
 297                 wake_up(&rdev->dev_wait);
 298                 break;
 299         case NETDEV_UP:
 300                 cfg802154_update_iface_num(rdev, wpan_dev->iftype, 1);
 301
 302                 rdev->opencount++;
 303                 break;
 304         case NETDEV_UNREGISTER:
 305                 /* It is possible to get NETDEV_UNREGISTER
 306                  * multiple times. To detect that, check
 307                  * that the interface is still on the list
 308                  * of registered interfaces, and only then
 309                  * remove and clean it up.
 310                  */
 311                 if (!list_empty(&wpan_dev->list)) {
 312                         list_del_rcu(&wpan_dev->list);
 313                         rdev->devlist_generation++;
 314                 }
 315                 /* synchronize (so that we won't find this netdev
 316                  * from other code any more) and then clear the list
 317                  * head so that the above code can safely check for
 318                  * !list_empty() to avoid double-cleanup.
 319                  */
 320                 synchronize_rcu();
 321                 INIT_LIST_HEAD(&wpan_dev->list);
 322                 break;
 323         default:
 324                 return NOTIFY_DONE;
 325         }
 326
 327         return NOTIFY_OK;
 328 }
 329
 330 static struct notifier_block cfg802154_netdev_notifier = {
 331         .notifier_call = cfg802154_netdev_notifier_call,
 332 };
 333
 334 static void __net_exit cfg802154_pernet_exit(struct net *net)
 335 {
 336         struct cfg802154_registered_device *rdev;
 337
 338         rtnl_lock();
 339         list_for_each_entry(rdev, &cfg802154_rdev_list, list) {
 340                 if (net_eq(wpan_phy_net(&rdev->wpan_phy), net))
 341                         WARN_ON(cfg802154_switch_netns(rdev, &init_net));
 342         }
 343         rtnl_unlock();
 344 }
 345
 346 static struct pernet_operations cfg802154_pernet_ops = {
 347         .exit = cfg802154_pernet_exit,
 348 };
 349
 350 static int __init wpan_phy_class_init(void)
 351 {
 352         int rc;
 353
 354         rc = register_pernet_device(&cfg802154_pernet_ops);
 355         if (rc)
 356                 goto err;
 357
 358         rc = wpan_phy_sysfs_init();
 359         if (rc)
 360                 goto err_sysfs;
 361
 362         rc = register_netdevice_notifier(&cfg802154_netdev_notifier);
 363         if (rc)
 364                 goto err_nl;
 365
 366         rc = ieee802154_nl_init();
 367         if (rc)
 368                 goto err_notifier;
 369
 370         rc = nl802154_init();
 371         if (rc)
 372                 goto err_ieee802154_nl;
 373
 374         return 0;
 375
 376 err_ieee802154_nl:
 377         ieee802154_nl_exit();
 378
 379 err_notifier:
 380         unregister_netdevice_notifier(&cfg802154_netdev_notifier);
 381 err_nl:
 382         wpan_phy_sysfs_exit();
 383 err_sysfs:
 384         unregister_pernet_device(&cfg802154_pernet_ops);
 385 err:
 386         return rc;
 387 }
 388 subsys_initcall(wpan_phy_class_init);
 389
 390 static void __exit wpan_phy_class_exit(void)
 391 {
 392         nl802154_exit();
 393         ieee802154_nl_exit();
 394         unregister_netdevice_notifier(&cfg802154_netdev_notifier);
 395         wpan_phy_sysfs_exit();
 396         unregister_pernet_device(&cfg802154_pernet_ops);
 397 }
 398 module_exit(wpan_phy_class_exit);
 399
 400 MODULE_LICENSE("GPL v2");
 401 MODULE_DESCRIPTION("IEEE 802.15.4 configuration interface");
 402 MODULE_AUTHOR("Dmitry Eremin-Solenikov");