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