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 rx_handler_func_t *rx_handler;
56 rx_handler = rcu_dereference(real_dev->rx_handler);
57 return (rx_handler == rmnet_rx_handler);
61 static struct rmnet_port*
62 rmnet_get_port_rtnl(const struct net_device *real_dev)
64 return rtnl_dereference(real_dev->rx_handler_data);
67 static struct rmnet_endpoint*
68 rmnet_get_endpoint(struct net_device *dev, int config_id)
70 struct rmnet_endpoint *ep;
71 struct rmnet_port *port;
73 if (!rmnet_is_real_dev_registered(dev)) {
74 ep = rmnet_vnd_get_endpoint(dev);
76 port = rmnet_get_port_rtnl(dev);
78 ep = &port->muxed_ep[config_id];
84 static int rmnet_unregister_real_device(struct net_device *real_dev,
85 struct rmnet_port *port)
87 if (port->nr_rmnet_devs)
92 netdev_rx_handler_unregister(real_dev);
94 /* release reference on real_dev */
97 netdev_dbg(real_dev, "Removed from rmnet\n");
101 static int rmnet_register_real_device(struct net_device *real_dev)
103 struct rmnet_port *port;
108 if (rmnet_is_real_dev_registered(real_dev))
111 port = kzalloc(sizeof(*port), GFP_ATOMIC);
115 port->dev = real_dev;
116 rc = netdev_rx_handler_register(real_dev, rmnet_rx_handler, port);
122 /* hold on to real dev for MAP data */
125 netdev_dbg(real_dev, "registered with rmnet\n");
129 static void rmnet_set_endpoint_config(struct net_device *dev,
130 u8 mux_id, u8 rmnet_mode,
131 struct net_device *egress_dev)
133 struct rmnet_endpoint *ep;
135 netdev_dbg(dev, "id %d mode %d dev %s\n",
136 mux_id, rmnet_mode, egress_dev->name);
138 ep = rmnet_get_endpoint(dev, mux_id);
139 /* This config is cleared on every set, so its ok to not
140 * clear it on a device delete.
142 memset(ep, 0, sizeof(struct rmnet_endpoint));
143 ep->rmnet_mode = rmnet_mode;
144 ep->egress_dev = egress_dev;
148 static int rmnet_newlink(struct net *src_net, struct net_device *dev,
149 struct nlattr *tb[], struct nlattr *data[],
150 struct netlink_ext_ack *extack)
152 int ingress_format = RMNET_INGRESS_FORMAT_DEMUXING |
153 RMNET_INGRESS_FORMAT_DEAGGREGATION |
154 RMNET_INGRESS_FORMAT_MAP;
155 int egress_format = RMNET_EGRESS_FORMAT_MUXING |
156 RMNET_EGRESS_FORMAT_MAP;
157 struct net_device *real_dev;
158 int mode = RMNET_EPMODE_VND;
159 struct rmnet_port *port;
163 real_dev = __dev_get_by_index(src_net, nla_get_u32(tb[IFLA_LINK]));
164 if (!real_dev || !dev)
167 if (!data[IFLA_VLAN_ID])
170 mux_id = nla_get_u16(data[IFLA_VLAN_ID]);
172 err = rmnet_register_real_device(real_dev);
176 port = rmnet_get_port_rtnl(real_dev);
177 err = rmnet_vnd_newlink(mux_id, dev, port, real_dev);
181 err = netdev_master_upper_dev_link(dev, real_dev, NULL, NULL);
185 netdev_dbg(dev, "data format [ingress 0x%08X] [egress 0x%08X]\n",
186 ingress_format, egress_format);
187 port->egress_data_format = egress_format;
188 port->ingress_data_format = ingress_format;
190 rmnet_set_endpoint_config(real_dev, mux_id, mode, dev);
191 rmnet_set_endpoint_config(dev, mux_id, mode, real_dev);
195 rmnet_vnd_dellink(mux_id, port);
197 rmnet_unregister_real_device(real_dev, port);
202 static void rmnet_dellink(struct net_device *dev, struct list_head *head)
204 struct net_device *real_dev;
205 struct rmnet_port *port;
209 real_dev = netdev_master_upper_dev_get_rcu(dev);
212 if (!real_dev || !rmnet_is_real_dev_registered(real_dev))
215 port = rmnet_get_port_rtnl(real_dev);
217 mux_id = rmnet_vnd_get_mux(dev);
218 rmnet_vnd_dellink(mux_id, port);
219 netdev_upper_dev_unlink(dev, real_dev);
220 rmnet_unregister_real_device(real_dev, port);
222 unregister_netdevice_queue(dev, head);
225 static int rmnet_dev_walk_unreg(struct net_device *rmnet_dev, void *data)
227 struct rmnet_walk_data *d = data;
230 mux_id = rmnet_vnd_get_mux(rmnet_dev);
232 rmnet_vnd_dellink(mux_id, d->port);
233 netdev_upper_dev_unlink(rmnet_dev, d->real_dev);
234 unregister_netdevice_queue(rmnet_dev, d->head);
239 static void rmnet_force_unassociate_device(struct net_device *dev)
241 struct net_device *real_dev = dev;
242 struct rmnet_walk_data d;
243 struct rmnet_port *port;
246 if (!rmnet_is_real_dev_registered(real_dev))
251 d.real_dev = real_dev;
254 port = rmnet_get_port_rtnl(dev);
258 netdev_walk_all_lower_dev_rcu(real_dev, rmnet_dev_walk_unreg, &d);
260 unregister_netdevice_many(&list);
262 rmnet_unregister_real_device(real_dev, port);
265 static int rmnet_config_notify_cb(struct notifier_block *nb,
266 unsigned long event, void *data)
268 struct net_device *dev = netdev_notifier_info_to_dev(data);
274 case NETDEV_UNREGISTER:
275 netdev_dbg(dev, "Kernel unregister\n");
276 rmnet_force_unassociate_device(dev);
286 static struct notifier_block rmnet_dev_notifier __read_mostly = {
287 .notifier_call = rmnet_config_notify_cb,
290 static int rmnet_rtnl_validate(struct nlattr *tb[], struct nlattr *data[],
291 struct netlink_ext_ack *extack)
295 if (!data || !data[IFLA_VLAN_ID])
298 mux_id = nla_get_u16(data[IFLA_VLAN_ID]);
299 if (mux_id > (RMNET_MAX_LOGICAL_EP - 1))
305 static size_t rmnet_get_size(const struct net_device *dev)
307 return nla_total_size(2); /* IFLA_VLAN_ID */
310 struct rtnl_link_ops rmnet_link_ops __read_mostly = {
312 .maxtype = __IFLA_VLAN_MAX,
313 .priv_size = sizeof(struct rmnet_priv),
314 .setup = rmnet_vnd_setup,
315 .validate = rmnet_rtnl_validate,
316 .newlink = rmnet_newlink,
317 .dellink = rmnet_dellink,
318 .get_size = rmnet_get_size,
321 /* Needs either rcu_read_lock() or rtnl lock */
322 struct rmnet_port *rmnet_get_port(struct net_device *real_dev)
324 if (rmnet_is_real_dev_registered(real_dev))
325 return rcu_dereference_rtnl(real_dev->rx_handler_data);
330 /* Startup/Shutdown */
332 static int __init rmnet_init(void)
336 rc = register_netdevice_notifier(&rmnet_dev_notifier);
340 rc = rtnl_link_register(&rmnet_link_ops);
342 unregister_netdevice_notifier(&rmnet_dev_notifier);
348 static void __exit rmnet_exit(void)
350 unregister_netdevice_notifier(&rmnet_dev_notifier);
351 rtnl_link_unregister(&rmnet_link_ops);
354 module_init(rmnet_init)
355 module_exit(rmnet_exit)
356 MODULE_LICENSE("GPL v2");