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

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