Skip to content

Commit

Permalink
Merge branch 'rmnet-Rewrite-some-existing-functionality'
Browse files Browse the repository at this point in the history 
Subash Abhinov Kasiviswanathan says:

====================
net: qualcomm: rmnet: Rewrite some existing functionality

This series fixes some of the broken rmnet functionality.
Bridge mode is re-written and made useable and the muxed_ep is converted to hlist.

Patches 1-5 are cleanups in preparation for these changes.
Patch 6 does the hlist conversion.
Patch 7 has the implementation of the rmnet bridge mode.

v1->v2: Fix the warning and code style issue in rmnet_rx_handler as
mentioned by David.
====================

Signed-off-by: David S. Miller <davem@davemloft.net>
  • Loading branch information
David S. Miller committed Oct 12, 2017
2 parents 5ef9d78 + 60d58f9 commit 7c6a86b
Show file tree
Hide file tree
Showing 8 changed files with 207 additions and 173 deletions.
166 changes: 127 additions & 39 deletions drivers/net/ethernet/qualcomm/rmnet/rmnet_config.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -61,23 +61,6 @@ rmnet_get_port_rtnl(const struct net_device *real_dev)
return rtnl_dereference(real_dev->rx_handler_data);
}

static struct rmnet_endpoint*
rmnet_get_endpoint(struct net_device *dev, int config_id)
{
struct rmnet_endpoint *ep;
struct rmnet_port *port;

if (!rmnet_is_real_dev_registered(dev)) {
ep = rmnet_vnd_get_endpoint(dev);
} else {
port = rmnet_get_port_rtnl(dev);

ep = &port->muxed_ep[config_id];
}

return ep;
}

static int rmnet_unregister_real_device(struct net_device *real_dev,
struct rmnet_port *port)
{
Expand All @@ -98,7 +81,7 @@ static int rmnet_unregister_real_device(struct net_device *real_dev,
static int rmnet_register_real_device(struct net_device *real_dev)
{
struct rmnet_port *port;
int rc;
int rc, entry;

ASSERT_RTNL();

Expand All @@ -119,27 +102,41 @@ static int rmnet_register_real_device(struct net_device *real_dev)
/* hold on to real dev for MAP data */
dev_hold(real_dev);

for (entry = 0; entry < RMNET_MAX_LOGICAL_EP; entry++)
INIT_HLIST_HEAD(&port->muxed_ep[entry]);

netdev_dbg(real_dev, "registered with rmnet\n");
return 0;
}

static void rmnet_set_endpoint_config(struct net_device *dev,
u8 mux_id, u8 rmnet_mode,
struct net_device *egress_dev)
static void rmnet_unregister_bridge(struct net_device *dev,
struct rmnet_port *port)
{
struct rmnet_endpoint *ep;
struct net_device *rmnet_dev, *bridge_dev;
struct rmnet_port *bridge_port;

if (port->rmnet_mode != RMNET_EPMODE_BRIDGE)
return;

netdev_dbg(dev, "id %d mode %d dev %s\n",
mux_id, rmnet_mode, egress_dev->name);
/* bridge slave handling */
if (!port->nr_rmnet_devs) {
rmnet_dev = netdev_master_upper_dev_get_rcu(dev);
netdev_upper_dev_unlink(dev, rmnet_dev);

ep = rmnet_get_endpoint(dev, mux_id);
/* This config is cleared on every set, so its ok to not
* clear it on a device delete.
*/
memset(ep, 0, sizeof(struct rmnet_endpoint));
ep->rmnet_mode = rmnet_mode;
ep->egress_dev = egress_dev;
ep->mux_id = mux_id;
bridge_dev = port->bridge_ep;

bridge_port = rmnet_get_port_rtnl(bridge_dev);
bridge_port->bridge_ep = NULL;
bridge_port->rmnet_mode = RMNET_EPMODE_VND;
} else {
bridge_dev = port->bridge_ep;

bridge_port = rmnet_get_port_rtnl(bridge_dev);
rmnet_dev = netdev_master_upper_dev_get_rcu(bridge_dev);
netdev_upper_dev_unlink(bridge_dev, rmnet_dev);

rmnet_unregister_real_device(bridge_dev, bridge_port);
}
}

static int rmnet_newlink(struct net *src_net, struct net_device *dev,
Expand All @@ -153,6 +150,7 @@ static int rmnet_newlink(struct net *src_net, struct net_device *dev,
RMNET_EGRESS_FORMAT_MAP;
struct net_device *real_dev;
int mode = RMNET_EPMODE_VND;
struct rmnet_endpoint *ep;
struct rmnet_port *port;
int err = 0;
u16 mux_id;
Expand All @@ -164,14 +162,18 @@ static int rmnet_newlink(struct net *src_net, struct net_device *dev,
if (!data[IFLA_VLAN_ID])
return -EINVAL;

ep = kzalloc(sizeof(*ep), GFP_ATOMIC);
if (!ep)
return -ENOMEM;

mux_id = nla_get_u16(data[IFLA_VLAN_ID]);

err = rmnet_register_real_device(real_dev);
if (err)
goto err0;

port = rmnet_get_port_rtnl(real_dev);
err = rmnet_vnd_newlink(mux_id, dev, port, real_dev);
err = rmnet_vnd_newlink(mux_id, dev, port, real_dev, ep);
if (err)
goto err1;

Expand All @@ -183,13 +185,13 @@ static int rmnet_newlink(struct net *src_net, struct net_device *dev,
ingress_format, egress_format);
port->egress_data_format = egress_format;
port->ingress_data_format = ingress_format;
port->rmnet_mode = mode;

rmnet_set_endpoint_config(real_dev, mux_id, mode, dev);
rmnet_set_endpoint_config(dev, mux_id, mode, real_dev);
hlist_add_head_rcu(&ep->hlnode, &port->muxed_ep[mux_id]);
return 0;

err2:
rmnet_vnd_dellink(mux_id, port);
rmnet_vnd_dellink(mux_id, port, ep);
err1:
rmnet_unregister_real_device(real_dev, port);
err0:
Expand All @@ -199,6 +201,7 @@ static int rmnet_newlink(struct net *src_net, struct net_device *dev,
static void rmnet_dellink(struct net_device *dev, struct list_head *head)
{
struct net_device *real_dev;
struct rmnet_endpoint *ep;
struct rmnet_port *port;
u8 mux_id;

Expand All @@ -212,8 +215,15 @@ static void rmnet_dellink(struct net_device *dev, struct list_head *head)
port = rmnet_get_port_rtnl(real_dev);

mux_id = rmnet_vnd_get_mux(dev);
rmnet_vnd_dellink(mux_id, port);
netdev_upper_dev_unlink(dev, real_dev);

ep = rmnet_get_endpoint(port, mux_id);
if (ep) {
hlist_del_init_rcu(&ep->hlnode);
rmnet_unregister_bridge(dev, port);
rmnet_vnd_dellink(mux_id, port, ep);
kfree(ep);
}
rmnet_unregister_real_device(real_dev, port);

unregister_netdevice_queue(dev, head);
Expand All @@ -222,11 +232,16 @@ static void rmnet_dellink(struct net_device *dev, struct list_head *head)
static int rmnet_dev_walk_unreg(struct net_device *rmnet_dev, void *data)
{
struct rmnet_walk_data *d = data;
struct rmnet_endpoint *ep;
u8 mux_id;

mux_id = rmnet_vnd_get_mux(rmnet_dev);

rmnet_vnd_dellink(mux_id, d->port);
ep = rmnet_get_endpoint(d->port, mux_id);
if (ep) {
hlist_del_init_rcu(&ep->hlnode);
rmnet_vnd_dellink(mux_id, d->port, ep);
kfree(ep);
}
netdev_upper_dev_unlink(rmnet_dev, d->real_dev);
unregister_netdevice_queue(rmnet_dev, d->head);

Expand All @@ -252,6 +267,8 @@ static void rmnet_force_unassociate_device(struct net_device *dev)
d.port = port;

rcu_read_lock();
rmnet_unregister_bridge(dev, port);

netdev_walk_all_lower_dev_rcu(real_dev, rmnet_dev_walk_unreg, &d);
rcu_read_unlock();
unregister_netdevice_many(&list);
Expand Down Expand Up @@ -324,6 +341,77 @@ struct rmnet_port *rmnet_get_port(struct net_device *real_dev)
return NULL;
}

struct rmnet_endpoint *rmnet_get_endpoint(struct rmnet_port *port, u8 mux_id)
{
struct rmnet_endpoint *ep;

hlist_for_each_entry_rcu(ep, &port->muxed_ep[mux_id], hlnode) {
if (ep->mux_id == mux_id)
return ep;
}

return NULL;
}

int rmnet_add_bridge(struct net_device *rmnet_dev,
struct net_device *slave_dev,
struct netlink_ext_ack *extack)
{
struct rmnet_priv *priv = netdev_priv(rmnet_dev);
struct net_device *real_dev = priv->real_dev;
struct rmnet_port *port, *slave_port;
int err;

port = rmnet_get_port(real_dev);

/* If there is more than one rmnet dev attached, its probably being
* used for muxing. Skip the briding in that case
*/
if (port->nr_rmnet_devs > 1)
return -EINVAL;

if (rmnet_is_real_dev_registered(slave_dev))
return -EBUSY;

err = rmnet_register_real_device(slave_dev);
if (err)
return -EBUSY;

err = netdev_master_upper_dev_link(slave_dev, rmnet_dev, NULL, NULL,
extack);
if (err)
return -EINVAL;

slave_port = rmnet_get_port(slave_dev);
slave_port->rmnet_mode = RMNET_EPMODE_BRIDGE;
slave_port->bridge_ep = real_dev;

port->rmnet_mode = RMNET_EPMODE_BRIDGE;
port->bridge_ep = slave_dev;

netdev_dbg(slave_dev, "registered with rmnet as slave\n");
return 0;
}

int rmnet_del_bridge(struct net_device *rmnet_dev,
struct net_device *slave_dev)
{
struct rmnet_priv *priv = netdev_priv(rmnet_dev);
struct net_device *real_dev = priv->real_dev;
struct rmnet_port *port, *slave_port;

port = rmnet_get_port(real_dev);
port->rmnet_mode = RMNET_EPMODE_VND;
port->bridge_ep = NULL;

netdev_upper_dev_unlink(slave_dev, rmnet_dev);
slave_port = rmnet_get_port(slave_dev);
rmnet_unregister_real_device(slave_dev, slave_port);

netdev_dbg(slave_dev, "removed from rmnet as slave\n");
return 0;
}

/* Startup/Shutdown */

static int __init rmnet_init(void)
Expand Down
19 changes: 10 additions & 9 deletions drivers/net/ethernet/qualcomm/rmnet/rmnet_config.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -20,36 +20,37 @@

#define RMNET_MAX_LOGICAL_EP 255

/* Information about the next device to deliver the packet to.
* Exact usage of this parameter depends on the rmnet_mode.
*/
struct rmnet_endpoint {
u8 rmnet_mode;
u8 mux_id;
struct net_device *egress_dev;
struct hlist_node hlnode;
};

/* One instance of this structure is instantiated for each real_dev associated
* with rmnet.
*/
struct rmnet_port {
struct net_device *dev;
struct rmnet_endpoint local_ep;
struct rmnet_endpoint muxed_ep[RMNET_MAX_LOGICAL_EP];
u32 ingress_data_format;
u32 egress_data_format;
struct net_device *rmnet_devices[RMNET_MAX_LOGICAL_EP];
u8 nr_rmnet_devs;
u8 rmnet_mode;
struct hlist_head muxed_ep[RMNET_MAX_LOGICAL_EP];
struct net_device *bridge_ep;
};

extern struct rtnl_link_ops rmnet_link_ops;

struct rmnet_priv {
struct rmnet_endpoint local_ep;
u8 mux_id;
struct net_device *real_dev;
};

struct rmnet_port *rmnet_get_port(struct net_device *real_dev);

struct rmnet_endpoint *rmnet_get_endpoint(struct rmnet_port *port, u8 mux_id);
int rmnet_add_bridge(struct net_device *rmnet_dev,
struct net_device *slave_dev,
struct netlink_ext_ack *extack);
int rmnet_del_bridge(struct net_device *rmnet_dev,
struct net_device *slave_dev);
#endif /* _RMNET_CONFIG_H_ */
Loading

0 comments on commit 7c6a86b

Please sign in to comment.