1 /* Copyright (c) 2013-2017, The Linux Foundation. All rights reserved. 2 * 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. 6 * 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. 11 * 12 * RMNET configuration engine 13 * 14 */ 15 16 #include <net/sock.h> 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" 24 25 /* Locking scheme - 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 41 * same context. 42 */ 43 44 /* Local Definitions and Declarations */ 45 46 static int rmnet_is_real_dev_registered(const struct net_device *real_dev) 47 { 48 return rcu_access_pointer(real_dev->rx_handler) == rmnet_rx_handler; 49 } 50 51 /* Needs rtnl lock */ 52 static struct rmnet_port* 53 rmnet_get_port_rtnl(const struct net_device *real_dev) 54 { 55 return rtnl_dereference(real_dev->rx_handler_data); 56 } 57 58 static int rmnet_unregister_real_device(struct net_device *real_dev, 59 struct rmnet_port *port) 60 { 61 if (port->nr_rmnet_devs) 62 return -EINVAL; 63 64 kfree(port); 65 66 netdev_rx_handler_unregister(real_dev); 67 68 /* release reference on real_dev */ 69 dev_put(real_dev); 70 71 netdev_dbg(real_dev, "Removed from rmnet\n"); 72 return 0; 73 } 74 75 static int rmnet_register_real_device(struct net_device *real_dev) 76 { 77 struct rmnet_port *port; 78 int rc, entry; 79 80 ASSERT_RTNL(); 81 82 if (rmnet_is_real_dev_registered(real_dev)) 83 return 0; 84 85 port = kzalloc(sizeof(*port), GFP_ATOMIC); 86 if (!port) 87 return -ENOMEM; 88 89 port->dev = real_dev; 90 rc = netdev_rx_handler_register(real_dev, rmnet_rx_handler, port); 91 if (rc) { 92 kfree(port); 93 return -EBUSY; 94 } 95 96 /* hold on to real dev for MAP data */ 97 dev_hold(real_dev); 98 99 for (entry = 0; entry < RMNET_MAX_LOGICAL_EP; entry++) 100 INIT_HLIST_HEAD(&port->muxed_ep[entry]); 101 102 netdev_dbg(real_dev, "registered with rmnet\n"); 103 return 0; 104 } 105 106 static void rmnet_unregister_bridge(struct net_device *dev, 107 struct rmnet_port *port) 108 { 109 struct rmnet_port *bridge_port; 110 struct net_device *bridge_dev; 111 112 if (port->rmnet_mode != RMNET_EPMODE_BRIDGE) 113 return; 114 115 /* bridge slave handling */ 116 if (!port->nr_rmnet_devs) { 117 bridge_dev = port->bridge_ep; 118 119 bridge_port = rmnet_get_port_rtnl(bridge_dev); 120 bridge_port->bridge_ep = NULL; 121 bridge_port->rmnet_mode = RMNET_EPMODE_VND; 122 } else { 123 bridge_dev = port->bridge_ep; 124 125 bridge_port = rmnet_get_port_rtnl(bridge_dev); 126 rmnet_unregister_real_device(bridge_dev, bridge_port); 127 } 128 } 129 130 static int rmnet_newlink(struct net *src_net, struct net_device *dev, 131 struct nlattr *tb[], struct nlattr *data[], 132 struct netlink_ext_ack *extack) 133 { 134 u32 data_format = RMNET_INGRESS_FORMAT_DEAGGREGATION; 135 struct net_device *real_dev; 136 int mode = RMNET_EPMODE_VND; 137 struct rmnet_endpoint *ep; 138 struct rmnet_port *port; 139 int err = 0; 140 u16 mux_id; 141 142 real_dev = __dev_get_by_index(src_net, nla_get_u32(tb[IFLA_LINK])); 143 if (!real_dev || !dev) 144 return -ENODEV; 145 146 if (!data[IFLA_VLAN_ID]) 147 return -EINVAL; 148 149 ep = kzalloc(sizeof(*ep), GFP_ATOMIC); 150 if (!ep) 151 return -ENOMEM; 152 153 mux_id = nla_get_u16(data[IFLA_VLAN_ID]); 154 155 err = rmnet_register_real_device(real_dev); 156 if (err) 157 goto err0; 158 159 port = rmnet_get_port_rtnl(real_dev); 160 err = rmnet_vnd_newlink(mux_id, dev, port, real_dev, ep); 161 if (err) 162 goto err1; 163 164 port->rmnet_mode = mode; 165 166 hlist_add_head_rcu(&ep->hlnode, &port->muxed_ep[mux_id]); 167 168 if (data[IFLA_VLAN_FLAGS]) { 169 struct ifla_vlan_flags *flags; 170 171 flags = nla_data(data[IFLA_VLAN_FLAGS]); 172 data_format = flags->flags & flags->mask; 173 } 174 175 netdev_dbg(dev, "data format [0x%08X]\n", data_format); 176 port->data_format = data_format; 177 178 return 0; 179 180 err1: 181 rmnet_unregister_real_device(real_dev, port); 182 err0: 183 kfree(ep); 184 return err; 185 } 186 187 static void rmnet_dellink(struct net_device *dev, struct list_head *head) 188 { 189 struct rmnet_priv *priv = netdev_priv(dev); 190 struct net_device *real_dev; 191 struct rmnet_endpoint *ep; 192 struct rmnet_port *port; 193 u8 mux_id; 194 195 real_dev = priv->real_dev; 196 197 if (!real_dev || !rmnet_is_real_dev_registered(real_dev)) 198 return; 199 200 port = rmnet_get_port_rtnl(real_dev); 201 202 mux_id = rmnet_vnd_get_mux(dev); 203 204 ep = rmnet_get_endpoint(port, mux_id); 205 if (ep) { 206 hlist_del_init_rcu(&ep->hlnode); 207 rmnet_unregister_bridge(dev, port); 208 rmnet_vnd_dellink(mux_id, port, ep); 209 kfree(ep); 210 } 211 rmnet_unregister_real_device(real_dev, port); 212 213 unregister_netdevice_queue(dev, head); 214 } 215 216 static void rmnet_force_unassociate_device(struct net_device *dev) 217 { 218 struct net_device *real_dev = dev; 219 struct hlist_node *tmp_ep; 220 struct rmnet_endpoint *ep; 221 struct rmnet_port *port; 222 unsigned long bkt_ep; 223 LIST_HEAD(list); 224 225 if (!rmnet_is_real_dev_registered(real_dev)) 226 return; 227 228 ASSERT_RTNL(); 229 230 port = rmnet_get_port_rtnl(dev); 231 232 rcu_read_lock(); 233 rmnet_unregister_bridge(dev, port); 234 235 hash_for_each_safe(port->muxed_ep, bkt_ep, tmp_ep, ep, hlnode) { 236 unregister_netdevice_queue(ep->egress_dev, &list); 237 rmnet_vnd_dellink(ep->mux_id, port, ep); 238 239 hlist_del_init_rcu(&ep->hlnode); 240 kfree(ep); 241 } 242 243 rcu_read_unlock(); 244 unregister_netdevice_many(&list); 245 246 rmnet_unregister_real_device(real_dev, port); 247 } 248 249 static int rmnet_config_notify_cb(struct notifier_block *nb, 250 unsigned long event, void *data) 251 { 252 struct net_device *dev = netdev_notifier_info_to_dev(data); 253 254 if (!dev) 255 return NOTIFY_DONE; 256 257 switch (event) { 258 case NETDEV_UNREGISTER: 259 netdev_dbg(dev, "Kernel unregister\n"); 260 rmnet_force_unassociate_device(dev); 261 break; 262 263 default: 264 break; 265 } 266 267 return NOTIFY_DONE; 268 } 269 270 static struct notifier_block rmnet_dev_notifier __read_mostly = { 271 .notifier_call = rmnet_config_notify_cb, 272 }; 273 274 static int rmnet_rtnl_validate(struct nlattr *tb[], struct nlattr *data[], 275 struct netlink_ext_ack *extack) 276 { 277 u16 mux_id; 278 279 if (!data || !data[IFLA_VLAN_ID]) 280 return -EINVAL; 281 282 mux_id = nla_get_u16(data[IFLA_VLAN_ID]); 283 if (mux_id > (RMNET_MAX_LOGICAL_EP - 1)) 284 return -ERANGE; 285 286 return 0; 287 } 288 289 static int rmnet_changelink(struct net_device *dev, struct nlattr *tb[], 290 struct nlattr *data[], 291 struct netlink_ext_ack *extack) 292 { 293 struct rmnet_priv *priv = netdev_priv(dev); 294 struct net_device *real_dev; 295 struct rmnet_endpoint *ep; 296 struct rmnet_port *port; 297 u16 mux_id; 298 299 real_dev = __dev_get_by_index(dev_net(dev), 300 nla_get_u32(tb[IFLA_LINK])); 301 302 if (!real_dev || !dev || !rmnet_is_real_dev_registered(real_dev)) 303 return -ENODEV; 304 305 port = rmnet_get_port_rtnl(real_dev); 306 307 if (data[IFLA_VLAN_ID]) { 308 mux_id = nla_get_u16(data[IFLA_VLAN_ID]); 309 ep = rmnet_get_endpoint(port, priv->mux_id); 310 311 hlist_del_init_rcu(&ep->hlnode); 312 hlist_add_head_rcu(&ep->hlnode, &port->muxed_ep[mux_id]); 313 314 ep->mux_id = mux_id; 315 priv->mux_id = mux_id; 316 } 317 318 if (data[IFLA_VLAN_FLAGS]) { 319 struct ifla_vlan_flags *flags; 320 321 flags = nla_data(data[IFLA_VLAN_FLAGS]); 322 port->data_format = flags->flags & flags->mask; 323 } 324 325 return 0; 326 } 327 328 static size_t rmnet_get_size(const struct net_device *dev) 329 { 330 return nla_total_size(2) /* IFLA_VLAN_ID */ + 331 nla_total_size(sizeof(struct ifla_vlan_flags)); /* IFLA_VLAN_FLAGS */ 332 } 333 334 struct rtnl_link_ops rmnet_link_ops __read_mostly = { 335 .kind = "rmnet", 336 .maxtype = __IFLA_VLAN_MAX, 337 .priv_size = sizeof(struct rmnet_priv), 338 .setup = rmnet_vnd_setup, 339 .validate = rmnet_rtnl_validate, 340 .newlink = rmnet_newlink, 341 .dellink = rmnet_dellink, 342 .get_size = rmnet_get_size, 343 .changelink = rmnet_changelink, 344 }; 345 346 /* Needs either rcu_read_lock() or rtnl lock */ 347 struct rmnet_port *rmnet_get_port(struct net_device *real_dev) 348 { 349 if (rmnet_is_real_dev_registered(real_dev)) 350 return rcu_dereference_rtnl(real_dev->rx_handler_data); 351 else 352 return NULL; 353 } 354 355 struct rmnet_endpoint *rmnet_get_endpoint(struct rmnet_port *port, u8 mux_id) 356 { 357 struct rmnet_endpoint *ep; 358 359 hlist_for_each_entry_rcu(ep, &port->muxed_ep[mux_id], hlnode) { 360 if (ep->mux_id == mux_id) 361 return ep; 362 } 363 364 return NULL; 365 } 366 367 int rmnet_add_bridge(struct net_device *rmnet_dev, 368 struct net_device *slave_dev, 369 struct netlink_ext_ack *extack) 370 { 371 struct rmnet_priv *priv = netdev_priv(rmnet_dev); 372 struct net_device *real_dev = priv->real_dev; 373 struct rmnet_port *port, *slave_port; 374 int err; 375 376 port = rmnet_get_port(real_dev); 377 378 /* If there is more than one rmnet dev attached, its probably being 379 * used for muxing. Skip the briding in that case 380 */ 381 if (port->nr_rmnet_devs > 1) 382 return -EINVAL; 383 384 if (rmnet_is_real_dev_registered(slave_dev)) 385 return -EBUSY; 386 387 err = rmnet_register_real_device(slave_dev); 388 if (err) 389 return -EBUSY; 390 391 slave_port = rmnet_get_port(slave_dev); 392 slave_port->rmnet_mode = RMNET_EPMODE_BRIDGE; 393 slave_port->bridge_ep = real_dev; 394 395 port->rmnet_mode = RMNET_EPMODE_BRIDGE; 396 port->bridge_ep = slave_dev; 397 398 netdev_dbg(slave_dev, "registered with rmnet as slave\n"); 399 return 0; 400 } 401 402 int rmnet_del_bridge(struct net_device *rmnet_dev, 403 struct net_device *slave_dev) 404 { 405 struct rmnet_priv *priv = netdev_priv(rmnet_dev); 406 struct net_device *real_dev = priv->real_dev; 407 struct rmnet_port *port, *slave_port; 408 409 port = rmnet_get_port(real_dev); 410 port->rmnet_mode = RMNET_EPMODE_VND; 411 port->bridge_ep = NULL; 412 413 slave_port = rmnet_get_port(slave_dev); 414 rmnet_unregister_real_device(slave_dev, slave_port); 415 416 netdev_dbg(slave_dev, "removed from rmnet as slave\n"); 417 return 0; 418 } 419 420 /* Startup/Shutdown */ 421 422 static int __init rmnet_init(void) 423 { 424 int rc; 425 426 rc = register_netdevice_notifier(&rmnet_dev_notifier); 427 if (rc != 0) 428 return rc; 429 430 rc = rtnl_link_register(&rmnet_link_ops); 431 if (rc != 0) { 432 unregister_netdevice_notifier(&rmnet_dev_notifier); 433 return rc; 434 } 435 return rc; 436 } 437 438 static void __exit rmnet_exit(void) 439 { 440 unregister_netdevice_notifier(&rmnet_dev_notifier); 441 rtnl_link_unregister(&rmnet_link_ops); 442 } 443 444 module_init(rmnet_init) 445 module_exit(rmnet_exit) 446 MODULE_LICENSE("GPL v2"); 447