1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * vxcan.c - Virtual CAN Tunnel for cross namespace communication 4 * 5 * This code is derived from drivers/net/can/vcan.c for the virtual CAN 6 * specific parts and from drivers/net/veth.c to implement the netlink API 7 * for network interface pairs in a common and established way. 8 * 9 * Copyright (c) 2017 Oliver Hartkopp <socketcan@hartkopp.net> 10 */ 11 12 #include <linux/ethtool.h> 13 #include <linux/module.h> 14 #include <linux/init.h> 15 #include <linux/netdevice.h> 16 #include <linux/if_arp.h> 17 #include <linux/if_ether.h> 18 #include <linux/can.h> 19 #include <linux/can/dev.h> 20 #include <linux/can/skb.h> 21 #include <linux/can/vxcan.h> 22 #include <linux/can/can-ml.h> 23 #include <linux/slab.h> 24 #include <net/can.h> 25 #include <net/rtnetlink.h> 26 27 #define DRV_NAME "vxcan" 28 29 MODULE_DESCRIPTION("Virtual CAN Tunnel"); 30 MODULE_LICENSE("GPL"); 31 MODULE_AUTHOR("Oliver Hartkopp <socketcan@hartkopp.net>"); 32 MODULE_ALIAS_RTNL_LINK(DRV_NAME); 33 34 struct vxcan_priv { 35 struct net_device __rcu *peer; 36 netdevice_tracker peer_tracker; 37 }; 38 39 static netdev_tx_t vxcan_xmit(struct sk_buff *oskb, struct net_device *dev) 40 { 41 struct vxcan_priv *priv = netdev_priv(dev); 42 struct net_device *peer; 43 struct net_device_stats *peerstats, *srcstats = &dev->stats; 44 struct can_skb_ext *csx; 45 struct sk_buff *skb; 46 unsigned int len; 47 48 if (can_dropped_invalid_skb(dev, oskb)) 49 return NETDEV_TX_OK; 50 51 rcu_read_lock(); 52 peer = rcu_dereference(priv->peer); 53 if (unlikely(!peer)) { 54 kfree_skb(oskb); 55 dev->stats.tx_dropped++; 56 goto out_unlock; 57 } 58 59 skb_tx_timestamp(oskb); 60 61 skb = skb_clone(oskb, GFP_ATOMIC); 62 if (skb) { 63 consume_skb(oskb); 64 } else { 65 kfree_skb(oskb); 66 goto out_unlock; 67 } 68 69 /* the cloned skb points to the skb extension of the already cloned 70 * oskb with an increased refcount. skb_ext_add() creates a copy to 71 * separate the skb extension data which is needed to start with a 72 * fresh can_gw_hops counter in the other namespace. 73 */ 74 csx = skb_ext_add(skb, SKB_EXT_CAN); 75 if (!csx) { 76 kfree_skb(skb); 77 goto out_unlock; 78 } 79 80 /* reset CAN GW hop counter */ 81 csx->can_gw_hops = 0; 82 skb->pkt_type = PACKET_BROADCAST; 83 skb->dev = peer; 84 skb->ip_summed = CHECKSUM_UNNECESSARY; 85 86 len = can_skb_get_data_len(skb); 87 if (netif_rx(skb) == NET_RX_SUCCESS) { 88 srcstats->tx_packets++; 89 srcstats->tx_bytes += len; 90 peerstats = &peer->stats; 91 peerstats->rx_packets++; 92 peerstats->rx_bytes += len; 93 } 94 95 out_unlock: 96 rcu_read_unlock(); 97 return NETDEV_TX_OK; 98 } 99 100 101 static int vxcan_open(struct net_device *dev) 102 { 103 struct vxcan_priv *priv = netdev_priv(dev); 104 struct net_device *peer = rtnl_dereference(priv->peer); 105 106 if (!peer) 107 return -ENOTCONN; 108 109 if (peer->flags & IFF_UP) { 110 netif_carrier_on(dev); 111 netif_carrier_on(peer); 112 } 113 return 0; 114 } 115 116 static int vxcan_close(struct net_device *dev) 117 { 118 struct vxcan_priv *priv = netdev_priv(dev); 119 struct net_device *peer = rtnl_dereference(priv->peer); 120 121 netif_carrier_off(dev); 122 if (peer) 123 netif_carrier_off(peer); 124 125 return 0; 126 } 127 128 static int vxcan_get_iflink(const struct net_device *dev) 129 { 130 struct vxcan_priv *priv = netdev_priv(dev); 131 struct net_device *peer; 132 int iflink; 133 134 rcu_read_lock(); 135 peer = rcu_dereference(priv->peer); 136 iflink = peer ? READ_ONCE(peer->ifindex) : 0; 137 rcu_read_unlock(); 138 139 return iflink; 140 } 141 142 static void vxcan_set_cap_info(struct net_device *dev) 143 { 144 u32 can_cap = CAN_CAP_CC; 145 146 if (dev->mtu > CAN_MTU) 147 can_cap |= CAN_CAP_FD; 148 149 if (dev->mtu >= CANXL_MIN_MTU) 150 can_cap |= CAN_CAP_XL; 151 152 can_set_cap(dev, can_cap); 153 } 154 155 static int vxcan_change_mtu(struct net_device *dev, int new_mtu) 156 { 157 /* Do not allow changing the MTU while running */ 158 if (dev->flags & IFF_UP) 159 return -EBUSY; 160 161 if (new_mtu != CAN_MTU && new_mtu != CANFD_MTU && 162 !can_is_canxl_dev_mtu(new_mtu)) 163 return -EINVAL; 164 165 WRITE_ONCE(dev->mtu, new_mtu); 166 vxcan_set_cap_info(dev); 167 return 0; 168 } 169 170 static const struct net_device_ops vxcan_netdev_ops = { 171 .ndo_open = vxcan_open, 172 .ndo_stop = vxcan_close, 173 .ndo_start_xmit = vxcan_xmit, 174 .ndo_get_iflink = vxcan_get_iflink, 175 .ndo_change_mtu = vxcan_change_mtu, 176 }; 177 178 static const struct ethtool_ops vxcan_ethtool_ops = { 179 .get_ts_info = ethtool_op_get_ts_info, 180 }; 181 182 static void vxcan_setup(struct net_device *dev) 183 { 184 struct can_ml_priv *can_ml; 185 186 dev->type = ARPHRD_CAN; 187 dev->mtu = CANXL_MTU; 188 dev->hard_header_len = 0; 189 dev->addr_len = 0; 190 dev->tx_queue_len = 0; 191 dev->flags = IFF_NOARP; 192 dev->netdev_ops = &vxcan_netdev_ops; 193 dev->ethtool_ops = &vxcan_ethtool_ops; 194 dev->needs_free_netdev = true; 195 196 can_ml = netdev_priv(dev) + ALIGN(sizeof(struct vxcan_priv), NETDEV_ALIGN); 197 can_set_ml_priv(dev, can_ml); 198 vxcan_set_cap_info(dev); 199 } 200 201 /* forward declaration for rtnl_create_link() */ 202 static struct rtnl_link_ops vxcan_link_ops; 203 204 static int vxcan_newlink(struct net_device *dev, 205 struct rtnl_newlink_params *params, 206 struct netlink_ext_ack *extack) 207 { 208 struct net *peer_net = rtnl_newlink_peer_net(params); 209 struct nlattr **data = params->data; 210 struct nlattr **tb = params->tb; 211 struct vxcan_priv *priv; 212 struct net_device *peer; 213 214 struct nlattr *peer_tb[IFLA_MAX + 1], **tbp = tb; 215 char ifname[IFNAMSIZ]; 216 unsigned char name_assign_type; 217 struct ifinfomsg *ifmp = NULL; 218 int err; 219 220 /* register peer device */ 221 if (data && data[VXCAN_INFO_PEER]) { 222 struct nlattr *nla_peer = data[VXCAN_INFO_PEER]; 223 224 ifmp = nla_data(nla_peer); 225 rtnl_nla_parse_ifinfomsg(peer_tb, nla_peer, extack); 226 tbp = peer_tb; 227 } 228 229 if (ifmp && tbp[IFLA_IFNAME]) { 230 nla_strscpy(ifname, tbp[IFLA_IFNAME], IFNAMSIZ); 231 name_assign_type = NET_NAME_USER; 232 } else { 233 snprintf(ifname, IFNAMSIZ, DRV_NAME "%%d"); 234 name_assign_type = NET_NAME_ENUM; 235 } 236 237 peer = rtnl_create_link(peer_net, ifname, name_assign_type, 238 &vxcan_link_ops, tbp, extack); 239 if (IS_ERR(peer)) 240 return PTR_ERR(peer); 241 242 if (ifmp && dev->ifindex) 243 peer->ifindex = ifmp->ifi_index; 244 245 err = register_netdevice(peer); 246 if (err < 0) { 247 free_netdev(peer); 248 return err; 249 } 250 251 netif_carrier_off(peer); 252 253 err = rtnl_configure_link(peer, ifmp, 0, NULL); 254 if (err < 0) 255 goto unregister_network_device; 256 257 /* register first device */ 258 if (tb[IFLA_IFNAME]) 259 nla_strscpy(dev->name, tb[IFLA_IFNAME], IFNAMSIZ); 260 else 261 snprintf(dev->name, IFNAMSIZ, DRV_NAME "%%d"); 262 263 err = register_netdevice(dev); 264 if (err < 0) 265 goto unregister_network_device; 266 267 netif_carrier_off(dev); 268 269 /* cross link the device pair */ 270 priv = netdev_priv(dev); 271 rcu_assign_pointer(priv->peer, peer); 272 netdev_hold(peer, &priv->peer_tracker, GFP_KERNEL); 273 274 priv = netdev_priv(peer); 275 rcu_assign_pointer(priv->peer, dev); 276 netdev_hold(dev, &priv->peer_tracker, GFP_KERNEL); 277 278 return 0; 279 280 unregister_network_device: 281 unregister_netdevice(peer); 282 return err; 283 } 284 285 static void vxcan_dellink(struct net_device *dev, struct list_head *head) 286 { 287 netdevice_tracker *peer_tracker; 288 struct vxcan_priv *priv; 289 struct net_device *peer; 290 291 priv = netdev_priv(dev); 292 peer_tracker = &priv->peer_tracker; 293 peer = unrcu_pointer(xchg(&priv->peer, NULL)); 294 if (!peer) 295 return; 296 297 unregister_netdevice_queue(dev, head); 298 299 priv = netdev_priv(peer); 300 dev = unrcu_pointer(xchg(&priv->peer, NULL)); 301 if (dev) 302 unregister_netdevice_queue_net(dev_net(dev), peer, head); 303 304 netdev_put(peer, peer_tracker); 305 netdev_put(dev, &priv->peer_tracker); 306 } 307 308 static const struct nla_policy vxcan_policy[VXCAN_INFO_MAX + 1] = { 309 [VXCAN_INFO_PEER] = { .len = sizeof(struct ifinfomsg) }, 310 }; 311 312 static struct net *vxcan_get_link_net(const struct net_device *dev) 313 { 314 struct vxcan_priv *priv = netdev_priv(dev); 315 struct net_device *peer = rtnl_dereference(priv->peer); 316 317 return peer ? dev_net(peer) : dev_net(dev); 318 } 319 320 static struct rtnl_link_ops vxcan_link_ops = { 321 .kind = DRV_NAME, 322 .priv_size = ALIGN(sizeof(struct vxcan_priv), NETDEV_ALIGN) + sizeof(struct can_ml_priv), 323 .setup = vxcan_setup, 324 .newlink = vxcan_newlink, 325 .dellink = vxcan_dellink, 326 .policy = vxcan_policy, 327 .peer_type = VXCAN_INFO_PEER, 328 .maxtype = VXCAN_INFO_MAX, 329 .get_link_net = vxcan_get_link_net, 330 }; 331 332 static __init int vxcan_init(void) 333 { 334 pr_info("vxcan: Virtual CAN Tunnel driver\n"); 335 336 return rtnl_link_register(&vxcan_link_ops); 337 } 338 339 static __exit void vxcan_exit(void) 340 { 341 rtnl_link_unregister(&vxcan_link_ops); 342 } 343 344 module_init(vxcan_init); 345 module_exit(vxcan_exit); 346