drivers/net/ethernet/qualcomm/rmnet/rmnet_config.c

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