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