xref: /openbmc/linux/net/ieee802154/core.c (revision b8d312aa) 
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