1 /* Copyright (c) 2013-2017, The Linux Foundation. All rights reserved.
3 * This program is free software; you can redistribute it and/or modify
4 * it under the terms of the GNU General Public License version 2 and
5 * only version 2 as published by the Free Software Foundation.
7 * This program is distributed in the hope that it will be useful,
8 * but WITHOUT ANY WARRANTY; without even the implied warranty of
9 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 * GNU General Public License for more details.
12 * RMNET configuration engine
17 #include <linux/module.h>
18 #include <linux/netlink.h>
19 #include <linux/netdevice.h>
20 #include "rmnet_config.h"
21 #include "rmnet_handlers.h"
22 #include "rmnet_vnd.h"
23 #include "rmnet_private.h"
26 * The shared resource which needs to be protected is realdev->rx_handler_data.
27 * For the writer path, this is using rtnl_lock(). The writer paths are
28 * rmnet_newlink(), rmnet_dellink() and rmnet_force_unassociate_device(). These
29 * paths are already called with rtnl_lock() acquired in. There is also an
30 * ASSERT_RTNL() to ensure that we are calling with rtnl acquired. For
31 * dereference here, we will need to use rtnl_dereference(). Dev list writing
32 * needs to happen with rtnl_lock() acquired for netdev_master_upper_dev_link().
33 * For the reader path, the real_dev->rx_handler_data is called in the TX / RX
34 * path. We only need rcu_read_lock() for these scenarios. In these cases,
35 * the rcu_read_lock() is held in __dev_queue_xmit() and
36 * netif_receive_skb_internal(), so readers need to use rcu_dereference_rtnl()
37 * to get the relevant information. For dev list reading, we again acquire
38 * rcu_read_lock() in rmnet_dellink() for netdev_master_upper_dev_get_rcu().
39 * We also use unregister_netdevice_many() to free all rmnet devices in
40 * rmnet_force_unassociate_device() so we dont lose the rtnl_lock() and free in
44 /* Local Definitions and Declarations */
46 struct rmnet_walk_data {
47 struct net_device *real_dev;
48 struct list_head *head;
49 struct rmnet_port *port;
52 static int rmnet_is_real_dev_registered(const struct net_device *real_dev)
54 return rcu_access_pointer(real_dev->rx_handler) == rmnet_rx_handler;
58 static struct rmnet_port*
59 rmnet_get_port_rtnl(const struct net_device *real_dev)
61 return rtnl_dereference(real_dev->rx_handler_data);
64 static struct rmnet_endpoint*
65 rmnet_get_endpoint(struct net_device *dev, int config_id)
67 struct rmnet_endpoint *ep;
68 struct rmnet_port *port;
70 if (!rmnet_is_real_dev_registered(dev)) {
71 ep = rmnet_vnd_get_endpoint(dev);
73 port = rmnet_get_port_rtnl(dev);
75 ep = &port->muxed_ep[config_id];
81 static int rmnet_unregister_real_device(struct net_device *real_dev,
82 struct rmnet_port *port)
84 if (port->nr_rmnet_devs)
87 netdev_rx_handler_unregister(real_dev);
91 /* release reference on real_dev */
94 netdev_dbg(real_dev, "Removed from rmnet\n");
98 static int rmnet_register_real_device(struct net_device *real_dev)
100 struct rmnet_port *port;
105 if (rmnet_is_real_dev_registered(real_dev))
108 port = kzalloc(sizeof(*port), GFP_ATOMIC);
112 port->dev = real_dev;
113 rc = netdev_rx_handler_register(real_dev, rmnet_rx_handler, port);
119 /* hold on to real dev for MAP data */
122 netdev_dbg(real_dev, "registered with rmnet\n");
126 static void rmnet_set_endpoint_config(struct net_device *dev,
127 u8 mux_id, u8 rmnet_mode,
128 struct net_device *egress_dev)
130 struct rmnet_endpoint *ep;
132 netdev_dbg(dev, "id %d mode %d dev %s\n",
133 mux_id, rmnet_mode, egress_dev->name);
135 ep = rmnet_get_endpoint(dev, mux_id);
136 /* This config is cleared on every set, so its ok to not
137 * clear it on a device delete.
139 memset(ep, 0, sizeof(struct rmnet_endpoint));
140 ep->rmnet_mode = rmnet_mode;
141 ep->egress_dev = egress_dev;
145 static int rmnet_newlink(struct net *src_net, struct net_device *dev,
146 struct nlattr *tb[], struct nlattr *data[],
147 struct netlink_ext_ack *extack)
149 int ingress_format = RMNET_INGRESS_FORMAT_DEMUXING |
150 RMNET_INGRESS_FORMAT_DEAGGREGATION |
151 RMNET_INGRESS_FORMAT_MAP;
152 int egress_format = RMNET_EGRESS_FORMAT_MUXING |
153 RMNET_EGRESS_FORMAT_MAP;
154 struct net_device *real_dev;
155 int mode = RMNET_EPMODE_VND;
156 struct rmnet_port *port;
160 if (!tb[IFLA_LINK]) {
161 NL_SET_ERR_MSG_MOD(extack, "link not specified");
165 real_dev = __dev_get_by_index(src_net, nla_get_u32(tb[IFLA_LINK]));
166 if (!real_dev || !dev)
169 if (!data[IFLA_VLAN_ID])
172 mux_id = nla_get_u16(data[IFLA_VLAN_ID]);
174 err = rmnet_register_real_device(real_dev);
178 port = rmnet_get_port_rtnl(real_dev);
179 err = rmnet_vnd_newlink(mux_id, dev, port, real_dev);
183 err = netdev_master_upper_dev_link(dev, real_dev, NULL, NULL);
187 netdev_dbg(dev, "data format [ingress 0x%08X] [egress 0x%08X]\n",
188 ingress_format, egress_format);
189 port->egress_data_format = egress_format;
190 port->ingress_data_format = ingress_format;
192 rmnet_set_endpoint_config(real_dev, mux_id, mode, dev);
193 rmnet_set_endpoint_config(dev, mux_id, mode, real_dev);
197 rmnet_vnd_dellink(mux_id, port);
199 rmnet_unregister_real_device(real_dev, port);
204 static void rmnet_dellink(struct net_device *dev, struct list_head *head)
206 struct net_device *real_dev;
207 struct rmnet_port *port;
211 real_dev = netdev_master_upper_dev_get_rcu(dev);
214 if (!real_dev || !rmnet_is_real_dev_registered(real_dev))
217 port = rmnet_get_port_rtnl(real_dev);
219 mux_id = rmnet_vnd_get_mux(dev);
220 rmnet_vnd_dellink(mux_id, port);
221 netdev_upper_dev_unlink(dev, real_dev);
222 rmnet_unregister_real_device(real_dev, port);
224 unregister_netdevice_queue(dev, head);
227 static int rmnet_dev_walk_unreg(struct net_device *rmnet_dev, void *data)
229 struct rmnet_walk_data *d = data;
232 mux_id = rmnet_vnd_get_mux(rmnet_dev);
234 rmnet_vnd_dellink(mux_id, d->port);
235 netdev_upper_dev_unlink(rmnet_dev, d->real_dev);
236 unregister_netdevice_queue(rmnet_dev, d->head);
241 static void rmnet_force_unassociate_device(struct net_device *dev)
243 struct net_device *real_dev = dev;
244 struct rmnet_walk_data d;
245 struct rmnet_port *port;
248 if (!rmnet_is_real_dev_registered(real_dev))
253 d.real_dev = real_dev;
256 port = rmnet_get_port_rtnl(dev);
260 netdev_walk_all_lower_dev_rcu(real_dev, rmnet_dev_walk_unreg, &d);
262 unregister_netdevice_many(&list);
264 rmnet_unregister_real_device(real_dev, port);
267 static int rmnet_config_notify_cb(struct notifier_block *nb,
268 unsigned long event, void *data)
270 struct net_device *dev = netdev_notifier_info_to_dev(data);
276 case NETDEV_UNREGISTER:
277 netdev_dbg(dev, "Kernel unregister\n");
278 rmnet_force_unassociate_device(dev);
288 static struct notifier_block rmnet_dev_notifier __read_mostly = {
289 .notifier_call = rmnet_config_notify_cb,
292 static int rmnet_rtnl_validate(struct nlattr *tb[], struct nlattr *data[],
293 struct netlink_ext_ack *extack)
297 if (!data || !data[IFLA_VLAN_ID])
300 mux_id = nla_get_u16(data[IFLA_VLAN_ID]);
301 if (mux_id > (RMNET_MAX_LOGICAL_EP - 1))
307 static size_t rmnet_get_size(const struct net_device *dev)
309 return nla_total_size(2); /* IFLA_VLAN_ID */
312 struct rtnl_link_ops rmnet_link_ops __read_mostly = {
314 .maxtype = __IFLA_VLAN_MAX,
315 .priv_size = sizeof(struct rmnet_priv),
316 .setup = rmnet_vnd_setup,
317 .validate = rmnet_rtnl_validate,
318 .newlink = rmnet_newlink,
319 .dellink = rmnet_dellink,
320 .get_size = rmnet_get_size,
323 /* Needs either rcu_read_lock() or rtnl lock */
324 struct rmnet_port *rmnet_get_port(struct net_device *real_dev)
326 if (rmnet_is_real_dev_registered(real_dev))
327 return rcu_dereference_rtnl(real_dev->rx_handler_data);
332 /* Startup/Shutdown */
334 static int __init rmnet_init(void)
338 rc = register_netdevice_notifier(&rmnet_dev_notifier);
342 rc = rtnl_link_register(&rmnet_link_ops);
344 unregister_netdevice_notifier(&rmnet_dev_notifier);
350 static void __exit rmnet_exit(void)
352 unregister_netdevice_notifier(&rmnet_dev_notifier);
353 rtnl_link_unregister(&rmnet_link_ops);
356 module_init(rmnet_init)
357 module_exit(rmnet_exit)
358 MODULE_LICENSE("GPL v2");