net/can/vxcan.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * vxcan.c - Virtual CAN Tunnel for cross namespace communication
0004  *
0005  * This code is derived from drivers/net/can/vcan.c for the virtual CAN
0006  * specific parts and from drivers/net/veth.c to implement the netlink API
0007  * for network interface pairs in a common and established way.
0008  *
0009  * Copyright (c) 2017 Oliver Hartkopp <socketcan@hartkopp.net>
0010  */
0011
0012 #include <linux/ethtool.h>
0013 #include <linux/module.h>
0014 #include <linux/init.h>
0015 #include <linux/netdevice.h>
0016 #include <linux/if_arp.h>
0017 #include <linux/if_ether.h>
0018 #include <linux/can.h>
0019 #include <linux/can/dev.h>
0020 #include <linux/can/skb.h>
0021 #include <linux/can/vxcan.h>
0022 #include <linux/can/can-ml.h>
0023 #include <linux/slab.h>
0024 #include <net/rtnetlink.h>
0025
0026 #define DRV_NAME "vxcan"
0027
0028 MODULE_DESCRIPTION("Virtual CAN Tunnel");
0029 MODULE_LICENSE("GPL");
0030 MODULE_AUTHOR("Oliver Hartkopp <socketcan@hartkopp.net>");
0031 MODULE_ALIAS_RTNL_LINK(DRV_NAME);
0032
0033 struct vxcan_priv {
0034     struct net_device __rcu *peer;
0035 };
0036
0037 static netdev_tx_t vxcan_xmit(struct sk_buff *oskb, struct net_device *dev)
0038 {
0039     struct vxcan_priv *priv = netdev_priv(dev);
0040     struct net_device *peer;
0041     struct canfd_frame *cfd = (struct canfd_frame *)oskb->data;
0042     struct net_device_stats *peerstats, *srcstats = &dev->stats;
0043     struct sk_buff *skb;
0044     u8 len;
0045
0046     if (can_dropped_invalid_skb(dev, oskb))
0047         return NETDEV_TX_OK;
0048
0049     rcu_read_lock();
0050     peer = rcu_dereference(priv->peer);
0051     if (unlikely(!peer)) {
0052         kfree_skb(oskb);
0053         dev->stats.tx_dropped++;
0054         goto out_unlock;
0055     }
0056
0057     skb_tx_timestamp(oskb);
0058
0059     skb = skb_clone(oskb, GFP_ATOMIC);
0060     if (skb) {
0061         consume_skb(oskb);
0062     } else {
0063         kfree_skb(oskb);
0064         goto out_unlock;
0065     }
0066
0067     /* reset CAN GW hop counter */
0068     skb->csum_start = 0;
0069     skb->pkt_type   = PACKET_BROADCAST;
0070     skb->dev        = peer;
0071     skb->ip_summed  = CHECKSUM_UNNECESSARY;
0072
0073     len = cfd->can_id & CAN_RTR_FLAG ? 0 : cfd->len;
0074     if (netif_rx(skb) == NET_RX_SUCCESS) {
0075         srcstats->tx_packets++;
0076         srcstats->tx_bytes += len;
0077         peerstats = &peer->stats;
0078         peerstats->rx_packets++;
0079         peerstats->rx_bytes += len;
0080     }
0081
0082 out_unlock:
0083     rcu_read_unlock();
0084     return NETDEV_TX_OK;
0085 }
0086
0087
0088 static int vxcan_open(struct net_device *dev)
0089 {
0090     struct vxcan_priv *priv = netdev_priv(dev);
0091     struct net_device *peer = rtnl_dereference(priv->peer);
0092
0093     if (!peer)
0094         return -ENOTCONN;
0095
0096     if (peer->flags & IFF_UP) {
0097         netif_carrier_on(dev);
0098         netif_carrier_on(peer);
0099     }
0100     return 0;
0101 }
0102
0103 static int vxcan_close(struct net_device *dev)
0104 {
0105     struct vxcan_priv *priv = netdev_priv(dev);
0106     struct net_device *peer = rtnl_dereference(priv->peer);
0107
0108     netif_carrier_off(dev);
0109     if (peer)
0110         netif_carrier_off(peer);
0111
0112     return 0;
0113 }
0114
0115 static int vxcan_get_iflink(const struct net_device *dev)
0116 {
0117     struct vxcan_priv *priv = netdev_priv(dev);
0118     struct net_device *peer;
0119     int iflink;
0120
0121     rcu_read_lock();
0122     peer = rcu_dereference(priv->peer);
0123     iflink = peer ? peer->ifindex : 0;
0124     rcu_read_unlock();
0125
0126     return iflink;
0127 }
0128
0129 static int vxcan_change_mtu(struct net_device *dev, int new_mtu)
0130 {
0131     /* Do not allow changing the MTU while running */
0132     if (dev->flags & IFF_UP)
0133         return -EBUSY;
0134
0135     if (new_mtu != CAN_MTU && new_mtu != CANFD_MTU)
0136         return -EINVAL;
0137
0138     dev->mtu = new_mtu;
0139     return 0;
0140 }
0141
0142 static const struct net_device_ops vxcan_netdev_ops = {
0143     .ndo_open   = vxcan_open,
0144     .ndo_stop   = vxcan_close,
0145     .ndo_start_xmit = vxcan_xmit,
0146     .ndo_get_iflink = vxcan_get_iflink,
0147     .ndo_change_mtu = vxcan_change_mtu,
0148 };
0149
0150 static const struct ethtool_ops vxcan_ethtool_ops = {
0151     .get_ts_info = ethtool_op_get_ts_info,
0152 };
0153
0154 static void vxcan_setup(struct net_device *dev)
0155 {
0156     struct can_ml_priv *can_ml;
0157
0158     dev->type       = ARPHRD_CAN;
0159     dev->mtu        = CANFD_MTU;
0160     dev->hard_header_len    = 0;
0161     dev->addr_len       = 0;
0162     dev->tx_queue_len   = 0;
0163     dev->flags      = IFF_NOARP;
0164     dev->netdev_ops     = &vxcan_netdev_ops;
0165     dev->ethtool_ops    = &vxcan_ethtool_ops;
0166     dev->needs_free_netdev  = true;
0167
0168     can_ml = netdev_priv(dev) + ALIGN(sizeof(struct vxcan_priv), NETDEV_ALIGN);
0169     can_set_ml_priv(dev, can_ml);
0170 }
0171
0172 /* forward declaration for rtnl_create_link() */
0173 static struct rtnl_link_ops vxcan_link_ops;
0174
0175 static int vxcan_newlink(struct net *net, struct net_device *dev,
0176              struct nlattr *tb[], struct nlattr *data[],
0177              struct netlink_ext_ack *extack)
0178 {
0179     struct vxcan_priv *priv;
0180     struct net_device *peer;
0181     struct net *peer_net;
0182
0183     struct nlattr *peer_tb[IFLA_MAX + 1], **tbp = tb;
0184     char ifname[IFNAMSIZ];
0185     unsigned char name_assign_type;
0186     struct ifinfomsg *ifmp = NULL;
0187     int err;
0188
0189     /* register peer device */
0190     if (data && data[VXCAN_INFO_PEER]) {
0191         struct nlattr *nla_peer;
0192
0193         nla_peer = data[VXCAN_INFO_PEER];
0194         ifmp = nla_data(nla_peer);
0195         err = rtnl_nla_parse_ifla(peer_tb,
0196                       nla_data(nla_peer) +
0197                       sizeof(struct ifinfomsg),
0198                       nla_len(nla_peer) -
0199                       sizeof(struct ifinfomsg),
0200                       NULL);
0201         if (err < 0)
0202             return err;
0203
0204         tbp = peer_tb;
0205     }
0206
0207     if (ifmp && tbp[IFLA_IFNAME]) {
0208         nla_strscpy(ifname, tbp[IFLA_IFNAME], IFNAMSIZ);
0209         name_assign_type = NET_NAME_USER;
0210     } else {
0211         snprintf(ifname, IFNAMSIZ, DRV_NAME "%%d");
0212         name_assign_type = NET_NAME_ENUM;
0213     }
0214
0215     peer_net = rtnl_link_get_net(net, tbp);
0216     if (IS_ERR(peer_net))
0217         return PTR_ERR(peer_net);
0218
0219     peer = rtnl_create_link(peer_net, ifname, name_assign_type,
0220                 &vxcan_link_ops, tbp, extack);
0221     if (IS_ERR(peer)) {
0222         put_net(peer_net);
0223         return PTR_ERR(peer);
0224     }
0225
0226     if (ifmp && dev->ifindex)
0227         peer->ifindex = ifmp->ifi_index;
0228
0229     err = register_netdevice(peer);
0230     put_net(peer_net);
0231     peer_net = NULL;
0232     if (err < 0) {
0233         free_netdev(peer);
0234         return err;
0235     }
0236
0237     netif_carrier_off(peer);
0238
0239     err = rtnl_configure_link(peer, ifmp);
0240     if (err < 0)
0241         goto unregister_network_device;
0242
0243     /* register first device */
0244     if (tb[IFLA_IFNAME])
0245         nla_strscpy(dev->name, tb[IFLA_IFNAME], IFNAMSIZ);
0246     else
0247         snprintf(dev->name, IFNAMSIZ, DRV_NAME "%%d");
0248
0249     err = register_netdevice(dev);
0250     if (err < 0)
0251         goto unregister_network_device;
0252
0253     netif_carrier_off(dev);
0254
0255     /* cross link the device pair */
0256     priv = netdev_priv(dev);
0257     rcu_assign_pointer(priv->peer, peer);
0258
0259     priv = netdev_priv(peer);
0260     rcu_assign_pointer(priv->peer, dev);
0261
0262     return 0;
0263
0264 unregister_network_device:
0265     unregister_netdevice(peer);
0266     return err;
0267 }
0268
0269 static void vxcan_dellink(struct net_device *dev, struct list_head *head)
0270 {
0271     struct vxcan_priv *priv;
0272     struct net_device *peer;
0273
0274     priv = netdev_priv(dev);
0275     peer = rtnl_dereference(priv->peer);
0276
0277     /* Note : dellink() is called from default_device_exit_batch(),
0278      * before a rcu_synchronize() point. The devices are guaranteed
0279      * not being freed before one RCU grace period.
0280      */
0281     RCU_INIT_POINTER(priv->peer, NULL);
0282     unregister_netdevice_queue(dev, head);
0283
0284     if (peer) {
0285         priv = netdev_priv(peer);
0286         RCU_INIT_POINTER(priv->peer, NULL);
0287         unregister_netdevice_queue(peer, head);
0288     }
0289 }
0290
0291 static const struct nla_policy vxcan_policy[VXCAN_INFO_MAX + 1] = {
0292     [VXCAN_INFO_PEER] = { .len = sizeof(struct ifinfomsg) },
0293 };
0294
0295 static struct net *vxcan_get_link_net(const struct net_device *dev)
0296 {
0297     struct vxcan_priv *priv = netdev_priv(dev);
0298     struct net_device *peer = rtnl_dereference(priv->peer);
0299
0300     return peer ? dev_net(peer) : dev_net(dev);
0301 }
0302
0303 static struct rtnl_link_ops vxcan_link_ops = {
0304     .kind       = DRV_NAME,
0305     .priv_size  = ALIGN(sizeof(struct vxcan_priv), NETDEV_ALIGN) + sizeof(struct can_ml_priv),
0306     .setup      = vxcan_setup,
0307     .newlink    = vxcan_newlink,
0308     .dellink    = vxcan_dellink,
0309     .policy     = vxcan_policy,
0310     .maxtype    = VXCAN_INFO_MAX,
0311     .get_link_net   = vxcan_get_link_net,
0312 };
0313
0314 static __init int vxcan_init(void)
0315 {
0316     pr_info("vxcan: Virtual CAN Tunnel driver\n");
0317
0318     return rtnl_link_register(&vxcan_link_ops);
0319 }
0320
0321 static __exit void vxcan_exit(void)
0322 {
0323     rtnl_link_unregister(&vxcan_link_ops);
0324 }
0325
0326 module_init(vxcan_init);
0327 module_exit(vxcan_exit);