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 struct rmnet_endpoint*
  65 rmnet_get_endpoint(struct net_device *dev, int config_id)
  66 {
  67         struct rmnet_endpoint *ep;
  68         struct rmnet_port *port;
  69
  70         if (!rmnet_is_real_dev_registered(dev)) {
  71                 ep = rmnet_vnd_get_endpoint(dev);
  72         } else {
  73                 port = rmnet_get_port_rtnl(dev);
  74
  75                 ep = &port->muxed_ep[config_id];
  76         }
  77
  78         return ep;
  79 }
  80
  81 static int rmnet_unregister_real_device(struct net_device *real_dev,
  82                                         struct rmnet_port *port)
  83 {
  84         if (port->nr_rmnet_devs)
  85                 return -EINVAL;
  86
  87         netdev_rx_handler_unregister(real_dev);
  88
  89         kfree(port);
  90
  91         /* release reference on real_dev */
  92         dev_put(real_dev);
  93
  94         netdev_dbg(real_dev, "Removed from rmnet\n");
  95         return 0;
  96 }
  97
  98 static int rmnet_register_real_device(struct net_device *real_dev)
  99 {
 100         struct rmnet_port *port;
 101         int rc;
 102
 103         ASSERT_RTNL();
 104
 105         if (rmnet_is_real_dev_registered(real_dev))
 106                 return 0;
 107
 108         port = kzalloc(sizeof(*port), GFP_ATOMIC);
 109         if (!port)
 110                 return -ENOMEM;
 111
 112         port->dev = real_dev;
 113         rc = netdev_rx_handler_register(real_dev, rmnet_rx_handler, port);
 114         if (rc) {
 115                 kfree(port);
 116                 return -EBUSY;
 117         }
 118
 119         /* hold on to real dev for MAP data */
 120         dev_hold(real_dev);
 121
 122         netdev_dbg(real_dev, "registered with rmnet\n");
 123         return 0;
 124 }
 125
 126 static void rmnet_set_endpoint_config(struct net_device *dev,
 127                                       u8 mux_id, u8 rmnet_mode,
 128                                       struct net_device *egress_dev)
 129 {
 130         struct rmnet_endpoint *ep;
 131
 132         netdev_dbg(dev, "id %d mode %d dev %s\n",
 133                    mux_id, rmnet_mode, egress_dev->name);
 134
 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.
 138          */
 139         memset(ep, 0, sizeof(struct rmnet_endpoint));
 140         ep->rmnet_mode = rmnet_mode;
 141         ep->egress_dev = egress_dev;
 142         ep->mux_id = mux_id;
 143 }
 144
 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)
 148 {
 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;
 157         int err = 0;
 158         u16 mux_id;
 159
 160         if (!tb[IFLA_LINK]) {
 161                 NL_SET_ERR_MSG_MOD(extack, "link not specified");
 162                 return -EINVAL;
 163         }
 164
 165         real_dev = __dev_get_by_index(src_net, nla_get_u32(tb[IFLA_LINK]));
 166         if (!real_dev || !dev)
 167                 return -ENODEV;
 168
 169         if (!data[IFLA_VLAN_ID])
 170                 return -EINVAL;
 171
 172         mux_id = nla_get_u16(data[IFLA_VLAN_ID]);
 173
 174         err = rmnet_register_real_device(real_dev);
 175         if (err)
 176                 goto err0;
 177
 178         port = rmnet_get_port_rtnl(real_dev);
 179         err = rmnet_vnd_newlink(mux_id, dev, port, real_dev);
 180         if (err)
 181                 goto err1;
 182
 183         err = netdev_master_upper_dev_link(dev, real_dev, NULL, NULL);
 184         if (err)
 185                 goto err2;
 186
 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;
 191
 192         rmnet_set_endpoint_config(real_dev, mux_id, mode, dev);
 193         rmnet_set_endpoint_config(dev, mux_id, mode, real_dev);
 194         return 0;
 195
 196 err2:
 197         rmnet_vnd_dellink(mux_id, port);
 198 err1:
 199         rmnet_unregister_real_device(real_dev, port);
 200 err0:
 201         return err;
 202 }
 203
 204 static void rmnet_dellink(struct net_device *dev, struct list_head *head)
 205 {
 206         struct net_device *real_dev;
 207         struct rmnet_port *port;
 208         u8 mux_id;
 209
 210         rcu_read_lock();
 211         real_dev = netdev_master_upper_dev_get_rcu(dev);
 212         rcu_read_unlock();
 213
 214         if (!real_dev || !rmnet_is_real_dev_registered(real_dev))
 215                 return;
 216
 217         port = rmnet_get_port_rtnl(real_dev);
 218
 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);
 223
 224         unregister_netdevice_queue(dev, head);
 225 }
 226
 227 static int rmnet_dev_walk_unreg(struct net_device *rmnet_dev, void *data)
 228 {
 229         struct rmnet_walk_data *d = data;
 230         u8 mux_id;
 231
 232         mux_id = rmnet_vnd_get_mux(rmnet_dev);
 233
 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);
 237
 238         return 0;
 239 }
 240
 241 static void rmnet_force_unassociate_device(struct net_device *dev)
 242 {
 243         struct net_device *real_dev = dev;
 244         struct rmnet_walk_data d;
 245         struct rmnet_port *port;
 246         LIST_HEAD(list);
 247
 248         if (!rmnet_is_real_dev_registered(real_dev))
 249                 return;
 250
 251         ASSERT_RTNL();
 252
 253         d.real_dev = real_dev;
 254         d.head = &list;
 255
 256         port = rmnet_get_port_rtnl(dev);
 257         d.port = port;
 258
 259         rcu_read_lock();
 260         netdev_walk_all_lower_dev_rcu(real_dev, rmnet_dev_walk_unreg, &d);
 261         rcu_read_unlock();
 262         unregister_netdevice_many(&list);
 263
 264         rmnet_unregister_real_device(real_dev, port);
 265 }
 266
 267 static int rmnet_config_notify_cb(struct notifier_block *nb,
 268                                   unsigned long event, void *data)
 269 {
 270         struct net_device *dev = netdev_notifier_info_to_dev(data);
 271
 272         if (!dev)
 273                 return NOTIFY_DONE;
 274
 275         switch (event) {
 276         case NETDEV_UNREGISTER:
 277                 netdev_dbg(dev, "Kernel unregister\n");
 278                 rmnet_force_unassociate_device(dev);
 279                 break;
 280
 281         default:
 282                 break;
 283         }
 284
 285         return NOTIFY_DONE;
 286 }
 287
 288 static struct notifier_block rmnet_dev_notifier __read_mostly = {
 289         .notifier_call = rmnet_config_notify_cb,
 290 };
 291
 292 static int rmnet_rtnl_validate(struct nlattr *tb[], struct nlattr *data[],
 293                                struct netlink_ext_ack *extack)
 294 {
 295         u16 mux_id;
 296
 297         if (!data || !data[IFLA_VLAN_ID])
 298                 return -EINVAL;
 299
 300         mux_id = nla_get_u16(data[IFLA_VLAN_ID]);
 301         if (mux_id > (RMNET_MAX_LOGICAL_EP - 1))
 302                 return -ERANGE;
 303
 304         return 0;
 305 }
 306
 307 static size_t rmnet_get_size(const struct net_device *dev)
 308 {
 309         return nla_total_size(2); /* IFLA_VLAN_ID */
 310 }
 311
 312 struct rtnl_link_ops rmnet_link_ops __read_mostly = {
 313         .kind           = "rmnet",
 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,
 321 };
 322
 323 /* Needs either rcu_read_lock() or rtnl lock */
 324 struct rmnet_port *rmnet_get_port(struct net_device *real_dev)
 325 {
 326         if (rmnet_is_real_dev_registered(real_dev))
 327                 return rcu_dereference_rtnl(real_dev->rx_handler_data);
 328         else
 329                 return NULL;
 330 }
 331
 332 /* Startup/Shutdown */
 333
 334 static int __init rmnet_init(void)
 335 {
 336         int rc;
 337
 338         rc = register_netdevice_notifier(&rmnet_dev_notifier);
 339         if (rc != 0)
 340                 return rc;
 341
 342         rc = rtnl_link_register(&rmnet_link_ops);
 343         if (rc != 0) {
 344                 unregister_netdevice_notifier(&rmnet_dev_notifier);
 345                 return rc;
 346         }
 347         return rc;
 348 }
 349
 350 static void __exit rmnet_exit(void)
 351 {
 352         unregister_netdevice_notifier(&rmnet_dev_notifier);
 353         rtnl_link_unregister(&rmnet_link_ops);
 354 }
 355
 356 module_init(rmnet_init)
 357 module_exit(rmnet_exit)
 358 MODULE_LICENSE("GPL v2");