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