bareudp.c

  1// SPDX-License-Identifier: GPL-2.0
  2/* Bareudp: UDP  tunnel encasulation for different Payload types like
  3 * MPLS, NSH, IP, etc.
  4 * Copyright (c) 2019 Nokia, Inc.
  5 * Authors:  Martin Varghese, <martin.varghese@nokia.com>
  6 */
  7
  8#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  9
 10#include <linux/kernel.h>
 11#include <linux/module.h>
 12#include <linux/etherdevice.h>
 13#include <linux/hash.h>
 14#include <net/dst_metadata.h>
 15#include <net/gro_cells.h>
 16#include <net/rtnetlink.h>
 17#include <net/protocol.h>
 18#include <net/ip6_tunnel.h>
 19#include <net/ip_tunnels.h>
 20#include <net/udp_tunnel.h>
 21#include <net/bareudp.h>
 22
 23#define BAREUDP_BASE_HLEN sizeof(struct udphdr)
 24#define BAREUDP_IPV4_HLEN (sizeof(struct iphdr) + \
 25			   sizeof(struct udphdr))
 26#define BAREUDP_IPV6_HLEN (sizeof(struct ipv6hdr) + \
 27			   sizeof(struct udphdr))
 28
 29static bool log_ecn_error = true;
 30module_param(log_ecn_error, bool, 0644);
 31MODULE_PARM_DESC(log_ecn_error, "Log packets received with corrupted ECN");
 32
 33/* per-network namespace private data for this module */
 34
 35static unsigned int bareudp_net_id;
 36
 37struct bareudp_net {
 38	struct list_head        bareudp_list;
 39};
 40
 41struct bareudp_conf {
 42	__be16 ethertype;
 43	__be16 port;
 44	u16 sport_min;
 45	bool multi_proto_mode;
 46};
 47
 48/* Pseudo network device */
 49struct bareudp_dev {
 50	struct net         *net;        /* netns for packet i/o */
 51	struct net_device  *dev;        /* netdev for bareudp tunnel */
 52	__be16		   ethertype;
 53	__be16             port;
 54	u16	           sport_min;
 55	bool               multi_proto_mode;
 56	struct socket      __rcu *sock;
 57	struct list_head   next;        /* bareudp node  on namespace list */
 58	struct gro_cells   gro_cells;
 59};
 60
 61static int bareudp_udp_encap_recv(struct sock *sk, struct sk_buff *skb)
 62{
 63	struct metadata_dst *tun_dst = NULL;
 64	IP_TUNNEL_DECLARE_FLAGS(key) = { };
 65	struct bareudp_dev *bareudp;
 66	unsigned short family;
 67	unsigned int len;
 68	__be16 proto;
 69	void *oiph;
 70	int err;
 71	int nh;
 72
 73	bareudp = rcu_dereference_sk_user_data(sk);
 74	if (!bareudp)
 75		goto drop;
 76
 77	if (skb->protocol ==  htons(ETH_P_IP))
 78		family = AF_INET;
 79	else
 80		family = AF_INET6;
 81
 82	if (bareudp->ethertype == htons(ETH_P_IP)) {
 83		__u8 ipversion;
 84
 85		if (skb_copy_bits(skb, BAREUDP_BASE_HLEN, &ipversion,
 86				  sizeof(ipversion))) {
 87			dev_dstats_rx_dropped(bareudp->dev);
 88			goto drop;
 89		}
 90		ipversion >>= 4;
 91
 92		if (ipversion == 4) {
 93			proto = htons(ETH_P_IP);
 94		} else if (ipversion == 6 && bareudp->multi_proto_mode) {
 95			proto = htons(ETH_P_IPV6);
 96		} else {
 97			dev_dstats_rx_dropped(bareudp->dev);
 98			goto drop;
 99		}
100	} else if (bareudp->ethertype == htons(ETH_P_MPLS_UC)) {
101		struct iphdr *tunnel_hdr;
102
103		tunnel_hdr = (struct iphdr *)skb_network_header(skb);
104		if (tunnel_hdr->version == 4) {
105			if (!ipv4_is_multicast(tunnel_hdr->daddr)) {
106				proto = bareudp->ethertype;
107			} else if (bareudp->multi_proto_mode &&
108				   ipv4_is_multicast(tunnel_hdr->daddr)) {
109				proto = htons(ETH_P_MPLS_MC);
110			} else {
111				dev_dstats_rx_dropped(bareudp->dev);
112				goto drop;
113			}
114		} else {
115			int addr_type;
116			struct ipv6hdr *tunnel_hdr_v6;
117
118			tunnel_hdr_v6 = (struct ipv6hdr *)skb_network_header(skb);
119			addr_type =
120			ipv6_addr_type((struct in6_addr *)&tunnel_hdr_v6->daddr);
121			if (!(addr_type & IPV6_ADDR_MULTICAST)) {
122				proto = bareudp->ethertype;
123			} else if (bareudp->multi_proto_mode &&
124				   (addr_type & IPV6_ADDR_MULTICAST)) {
125				proto = htons(ETH_P_MPLS_MC);
126			} else {
127				dev_dstats_rx_dropped(bareudp->dev);
128				goto drop;
129			}
130		}
131	} else {
132		proto = bareudp->ethertype;
133	}
134
135	if (iptunnel_pull_header(skb, BAREUDP_BASE_HLEN,
136				 proto,
137				 !net_eq(bareudp->net,
138				 dev_net(bareudp->dev)))) {
139		dev_dstats_rx_dropped(bareudp->dev);
140		goto drop;
141	}
142
143	__set_bit(IP_TUNNEL_KEY_BIT, key);
144
145	tun_dst = udp_tun_rx_dst(skb, family, key, 0, 0);
146	if (!tun_dst) {
147		dev_dstats_rx_dropped(bareudp->dev);
148		goto drop;
149	}
150	skb_dst_set(skb, &tun_dst->dst);
151	skb->dev = bareudp->dev;
152	skb_reset_mac_header(skb);
153
154	/* Save offset of outer header relative to skb->head,
155	 * because we are going to reset the network header to the inner header
156	 * and might change skb->head.
157	 */
158	nh = skb_network_header(skb) - skb->head;
159
160	skb_reset_network_header(skb);
161
162	if (!pskb_inet_may_pull(skb)) {
163		DEV_STATS_INC(bareudp->dev, rx_length_errors);
164		DEV_STATS_INC(bareudp->dev, rx_errors);
165		goto drop;
166	}
167
168	/* Get the outer header. */
169	oiph = skb->head + nh;
170
171	if (!ipv6_mod_enabled() || family == AF_INET)
172		err = IP_ECN_decapsulate(oiph, skb);
173	else
174		err = IP6_ECN_decapsulate(oiph, skb);
175
176	if (unlikely(err)) {
177		if (log_ecn_error) {
178			if  (!ipv6_mod_enabled() || family == AF_INET)
179				net_info_ratelimited("non-ECT from %pI4 "
180						     "with TOS=%#x\n",
181						     &((struct iphdr *)oiph)->saddr,
182						     ((struct iphdr *)oiph)->tos);
183			else
184				net_info_ratelimited("non-ECT from %pI6\n",
185						     &((struct ipv6hdr *)oiph)->saddr);
186		}
187		if (err > 1) {
188			DEV_STATS_INC(bareudp->dev, rx_frame_errors);
189			DEV_STATS_INC(bareudp->dev, rx_errors);
190			goto drop;
191		}
192	}
193
194	len = skb->len;
195	err = gro_cells_receive(&bareudp->gro_cells, skb);
196	if (likely(err == NET_RX_SUCCESS))
197		dev_dstats_rx_add(bareudp->dev, len);
198
199	return 0;
200drop:
201	/* Consume bad packet */
202	kfree_skb(skb);
203
204	return 0;
205}
206
207static int bareudp_err_lookup(struct sock *sk, struct sk_buff *skb)
208{
209	return 0;
210}
211
212static int bareudp_init(struct net_device *dev)
213{
214	struct bareudp_dev *bareudp = netdev_priv(dev);
215	int err;
216
217	err = gro_cells_init(&bareudp->gro_cells, dev);
218	if (err)
219		return err;
220
221	return 0;
222}
223
224static void bareudp_uninit(struct net_device *dev)
225{
226	struct bareudp_dev *bareudp = netdev_priv(dev);
227
228	gro_cells_destroy(&bareudp->gro_cells);
229}
230
231static struct socket *bareudp_create_sock(struct net *net, __be16 port)
232{
233	struct udp_port_cfg udp_conf;
234	struct socket *sock;
235	int err;
236
237	memset(&udp_conf, 0, sizeof(udp_conf));
238
239	if (ipv6_mod_enabled())
240		udp_conf.family = AF_INET6;
241	else
242		udp_conf.family = AF_INET;
243
244	udp_conf.local_udp_port = port;
245	/* Open UDP socket */
246	err = udp_sock_create(net, &udp_conf, &sock);
247	if (err < 0)
248		return ERR_PTR(err);
249
250	udp_allow_gso(sock->sk);
251	return sock;
252}
253
254/* Create new listen socket if needed */
255static int bareudp_socket_create(struct bareudp_dev *bareudp, __be16 port)
256{
257	struct udp_tunnel_sock_cfg tunnel_cfg;
258	struct socket *sock;
259
260	sock = bareudp_create_sock(bareudp->net, port);
261	if (IS_ERR(sock))
262		return PTR_ERR(sock);
263
264	/* Mark socket as an encapsulation socket */
265	memset(&tunnel_cfg, 0, sizeof(tunnel_cfg));
266	tunnel_cfg.sk_user_data = bareudp;
267	tunnel_cfg.encap_type = 1;
268	tunnel_cfg.encap_rcv = bareudp_udp_encap_recv;
269	tunnel_cfg.encap_err_lookup = bareudp_err_lookup;
270	tunnel_cfg.encap_destroy = NULL;
271	setup_udp_tunnel_sock(bareudp->net, sock, &tunnel_cfg);
272
273	rcu_assign_pointer(bareudp->sock, sock);
274	return 0;
275}
276
277static int bareudp_open(struct net_device *dev)
278{
279	struct bareudp_dev *bareudp = netdev_priv(dev);
280	int ret = 0;
281
282	ret =  bareudp_socket_create(bareudp, bareudp->port);
283	return ret;
284}
285
286static void bareudp_sock_release(struct bareudp_dev *bareudp)
287{
288	struct socket *sock;
289
290	sock = bareudp->sock;
291	rcu_assign_pointer(bareudp->sock, NULL);
292	synchronize_net();
293	udp_tunnel_sock_release(sock);
294}
295
296static int bareudp_stop(struct net_device *dev)
297{
298	struct bareudp_dev *bareudp = netdev_priv(dev);
299
300	bareudp_sock_release(bareudp);
301	return 0;
302}
303
304static int bareudp_xmit_skb(struct sk_buff *skb, struct net_device *dev,
305			    struct bareudp_dev *bareudp,
306			    const struct ip_tunnel_info *info)
307{
308	bool udp_sum = test_bit(IP_TUNNEL_CSUM_BIT, info->key.tun_flags);
309	bool xnet = !net_eq(bareudp->net, dev_net(bareudp->dev));
310	bool use_cache = ip_tunnel_dst_cache_usable(skb, info);
311	struct socket *sock = rcu_dereference(bareudp->sock);
312	const struct ip_tunnel_key *key = &info->key;
313	struct rtable *rt;
314	__be16 sport, df;
315	int min_headroom;
316	__u8 tos, ttl;
317	__be32 saddr;
318	int err;
319
320	if (skb_vlan_inet_prepare(skb, skb->protocol != htons(ETH_P_TEB)))
321		return -EINVAL;
322
323	if (!sock)
324		return -ESHUTDOWN;
325
326	sport = udp_flow_src_port(bareudp->net, skb,
327				  bareudp->sport_min, USHRT_MAX,
328				  true);
329	rt = udp_tunnel_dst_lookup(skb, dev, bareudp->net, 0, &saddr, &info->key,
330				   sport, bareudp->port, key->tos,
331				   use_cache ?
332				   (struct dst_cache *)&info->dst_cache : NULL);
333
334	if (IS_ERR(rt))
335		return PTR_ERR(rt);
336
337	skb_tunnel_check_pmtu(skb, &rt->dst,
338			      BAREUDP_IPV4_HLEN + info->options_len, false);
339
340	tos = ip_tunnel_ecn_encap(key->tos, ip_hdr(skb), skb);
341	ttl = key->ttl;
342	df = test_bit(IP_TUNNEL_DONT_FRAGMENT_BIT, key->tun_flags) ?
343	     htons(IP_DF) : 0;
344	skb_scrub_packet(skb, xnet);
345
346	err = -ENOSPC;
347	if (!skb_pull(skb, skb_network_offset(skb)))
348		goto free_dst;
349
350	min_headroom = LL_RESERVED_SPACE(rt->dst.dev) + rt->dst.header_len +
351		BAREUDP_BASE_HLEN + info->options_len + sizeof(struct iphdr);
352
353	err = skb_cow_head(skb, min_headroom);
354	if (unlikely(err))
355		goto free_dst;
356
357	err = udp_tunnel_handle_offloads(skb, udp_sum);
358	if (err)
359		goto free_dst;
360
361	skb_set_inner_protocol(skb, bareudp->ethertype);
362	udp_tunnel_xmit_skb(rt, sock->sk, skb, saddr, info->key.u.ipv4.dst,
363			    tos, ttl, df, sport, bareudp->port,
364			    !net_eq(bareudp->net, dev_net(bareudp->dev)),
365			    !test_bit(IP_TUNNEL_CSUM_BIT, info->key.tun_flags),
366			    0);
367	return 0;
368
369free_dst:
370	dst_release(&rt->dst);
371	return err;
372}
373
374static int bareudp6_xmit_skb(struct sk_buff *skb, struct net_device *dev,
375			     struct bareudp_dev *bareudp,
376			     const struct ip_tunnel_info *info)
377{
378	bool udp_sum = test_bit(IP_TUNNEL_CSUM_BIT, info->key.tun_flags);
379	bool xnet = !net_eq(bareudp->net, dev_net(bareudp->dev));
380	bool use_cache = ip_tunnel_dst_cache_usable(skb, info);
381	struct socket *sock  = rcu_dereference(bareudp->sock);
382	const struct ip_tunnel_key *key = &info->key;
383	struct dst_entry *dst = NULL;
384	struct in6_addr saddr, daddr;
385	int min_headroom;
386	__u8 prio, ttl;
387	__be16 sport;
388	int err;
389
390	if (skb_vlan_inet_prepare(skb, skb->protocol != htons(ETH_P_TEB)))
391		return -EINVAL;
392
393	if (!sock)
394		return -ESHUTDOWN;
395
396	sport = udp_flow_src_port(bareudp->net, skb,
397				  bareudp->sport_min, USHRT_MAX,
398				  true);
399	dst = udp_tunnel6_dst_lookup(skb, dev, bareudp->net, sock, 0, &saddr,
400				     key, sport, bareudp->port, key->tos,
401				     use_cache ?
402				     (struct dst_cache *) &info->dst_cache : NULL);
403	if (IS_ERR(dst))
404		return PTR_ERR(dst);
405
406	skb_tunnel_check_pmtu(skb, dst, BAREUDP_IPV6_HLEN + info->options_len,
407			      false);
408
409	prio = ip_tunnel_ecn_encap(key->tos, ip_hdr(skb), skb);
410	ttl = key->ttl;
411
412	skb_scrub_packet(skb, xnet);
413
414	err = -ENOSPC;
415	if (!skb_pull(skb, skb_network_offset(skb)))
416		goto free_dst;
417
418	min_headroom = LL_RESERVED_SPACE(dst->dev) + dst->header_len +
419		BAREUDP_BASE_HLEN + info->options_len + sizeof(struct ipv6hdr);
420
421	err = skb_cow_head(skb, min_headroom);
422	if (unlikely(err))
423		goto free_dst;
424
425	err = udp_tunnel_handle_offloads(skb, udp_sum);
426	if (err)
427		goto free_dst;
428
429	daddr = info->key.u.ipv6.dst;
430	udp_tunnel6_xmit_skb(dst, sock->sk, skb, dev,
431			     &saddr, &daddr, prio, ttl,
432			     info->key.label, sport, bareudp->port,
433			     !test_bit(IP_TUNNEL_CSUM_BIT,
434				       info->key.tun_flags),
435			     0);
436	return 0;
437
438free_dst:
439	dst_release(dst);
440	return err;
441}
442
443static bool bareudp_proto_valid(struct bareudp_dev *bareudp, __be16 proto)
444{
445	if (bareudp->ethertype == proto)
446		return true;
447
448	if (!bareudp->multi_proto_mode)
449		return false;
450
451	if (bareudp->ethertype == htons(ETH_P_MPLS_UC) &&
452	    proto == htons(ETH_P_MPLS_MC))
453		return true;
454
455	if (bareudp->ethertype == htons(ETH_P_IP) &&
456	    proto == htons(ETH_P_IPV6))
457		return true;
458
459	return false;
460}
461
462static netdev_tx_t bareudp_xmit(struct sk_buff *skb, struct net_device *dev)
463{
464	struct bareudp_dev *bareudp = netdev_priv(dev);
465	struct ip_tunnel_info *info = NULL;
466	int err;
467
468	if (!bareudp_proto_valid(bareudp, skb->protocol)) {
469		err = -EINVAL;
470		goto tx_error;
471	}
472
473	info = skb_tunnel_info(skb);
474	if (unlikely(!info || !(info->mode & IP_TUNNEL_INFO_TX))) {
475		err = -EINVAL;
476		goto tx_error;
477	}
478
479	rcu_read_lock();
480	if (ipv6_mod_enabled() && info->mode & IP_TUNNEL_INFO_IPV6)
481		err = bareudp6_xmit_skb(skb, dev, bareudp, info);
482	else
483		err = bareudp_xmit_skb(skb, dev, bareudp, info);
484
485	rcu_read_unlock();
486
487	if (likely(!err))
488		return NETDEV_TX_OK;
489tx_error:
490	dev_kfree_skb(skb);
491
492	if (err == -ELOOP)
493		DEV_STATS_INC(dev, collisions);
494	else if (err == -ENETUNREACH)
495		DEV_STATS_INC(dev, tx_carrier_errors);
496
497	DEV_STATS_INC(dev, tx_errors);
498	return NETDEV_TX_OK;
499}
500
501static int bareudp_fill_metadata_dst(struct net_device *dev,
502				     struct sk_buff *skb)
503{
504	struct ip_tunnel_info *info = skb_tunnel_info(skb);
505	struct bareudp_dev *bareudp = netdev_priv(dev);
506	bool use_cache;
507	__be16 sport;
508
509	use_cache = ip_tunnel_dst_cache_usable(skb, info);
510	sport = udp_flow_src_port(bareudp->net, skb,
511				  bareudp->sport_min, USHRT_MAX,
512				  true);
513
514	if (!ipv6_mod_enabled() || ip_tunnel_info_af(info) == AF_INET) {
515		struct rtable *rt;
516		__be32 saddr;
517
518		rt = udp_tunnel_dst_lookup(skb, dev, bareudp->net, 0, &saddr,
519					   &info->key, sport, bareudp->port,
520					   info->key.tos,
521					   use_cache ? &info->dst_cache : NULL);
522		if (IS_ERR(rt))
523			return PTR_ERR(rt);
524
525		ip_rt_put(rt);
526		info->key.u.ipv4.src = saddr;
527	} else if (ip_tunnel_info_af(info) == AF_INET6) {
528		struct dst_entry *dst;
529		struct in6_addr saddr;
530		struct socket *sock = rcu_dereference(bareudp->sock);
531
532		dst = udp_tunnel6_dst_lookup(skb, dev, bareudp->net, sock,
533					     0, &saddr, &info->key,
534					     sport, bareudp->port, info->key.tos,
535					     use_cache ? &info->dst_cache : NULL);
536		if (IS_ERR(dst))
537			return PTR_ERR(dst);
538
539		dst_release(dst);
540		info->key.u.ipv6.src = saddr;
541	} else {
542		return -EINVAL;
543	}
544
545	info->key.tp_src = sport;
546	info->key.tp_dst = bareudp->port;
547	return 0;
548}
549
550static const struct net_device_ops bareudp_netdev_ops = {
551	.ndo_init               = bareudp_init,
552	.ndo_uninit             = bareudp_uninit,
553	.ndo_open               = bareudp_open,
554	.ndo_stop               = bareudp_stop,
555	.ndo_start_xmit         = bareudp_xmit,
556	.ndo_fill_metadata_dst  = bareudp_fill_metadata_dst,
557};
558
559static const struct nla_policy bareudp_policy[IFLA_BAREUDP_MAX + 1] = {
560	[IFLA_BAREUDP_PORT]                = { .type = NLA_U16 },
561	[IFLA_BAREUDP_ETHERTYPE]	   = { .type = NLA_U16 },
562	[IFLA_BAREUDP_SRCPORT_MIN]         = { .type = NLA_U16 },
563	[IFLA_BAREUDP_MULTIPROTO_MODE]     = { .type = NLA_FLAG },
564};
565
566/* Info for udev, that this is a virtual tunnel endpoint */
567static const struct device_type bareudp_type = {
568	.name = "bareudp",
569};
570
571/* Initialize the device structure. */
572static void bareudp_setup(struct net_device *dev)
573{
574	dev->netdev_ops = &bareudp_netdev_ops;
575	dev->needs_free_netdev = true;
576	SET_NETDEV_DEVTYPE(dev, &bareudp_type);
577	dev->features    |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_FRAGLIST;
578	dev->features    |= NETIF_F_RXCSUM;
579	dev->features    |= NETIF_F_GSO_SOFTWARE;
580	dev->hw_features |= NETIF_F_SG | NETIF_F_HW_CSUM | NETIF_F_FRAGLIST;
581	dev->hw_features |= NETIF_F_RXCSUM;
582	dev->hw_features |= NETIF_F_GSO_SOFTWARE;
583	dev->hard_header_len = 0;
584	dev->addr_len = 0;
585	dev->mtu = ETH_DATA_LEN;
586	dev->min_mtu = IPV4_MIN_MTU;
587	dev->max_mtu = IP_MAX_MTU - BAREUDP_BASE_HLEN;
588	dev->type = ARPHRD_NONE;
589	netif_keep_dst(dev);
590	dev->priv_flags |= IFF_NO_QUEUE;
591	dev->lltx = true;
592	dev->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
593	dev->pcpu_stat_type = NETDEV_PCPU_STAT_DSTATS;
594}
595
596static int bareudp_validate(struct nlattr *tb[], struct nlattr *data[],
597			    struct netlink_ext_ack *extack)
598{
599	if (!data) {
600		NL_SET_ERR_MSG(extack,
601			       "Not enough attributes provided to perform the operation");
602		return -EINVAL;
603	}
604	return 0;
605}
606
607static int bareudp2info(struct nlattr *data[], struct bareudp_conf *conf,
608			struct netlink_ext_ack *extack)
609{
610	memset(conf, 0, sizeof(*conf));
611
612	if (!data[IFLA_BAREUDP_PORT]) {
613		NL_SET_ERR_MSG(extack, "port not specified");
614		return -EINVAL;
615	}
616	if (!data[IFLA_BAREUDP_ETHERTYPE]) {
617		NL_SET_ERR_MSG(extack, "ethertype not specified");
618		return -EINVAL;
619	}
620
621	conf->port = nla_get_u16(data[IFLA_BAREUDP_PORT]);
622	conf->ethertype = nla_get_u16(data[IFLA_BAREUDP_ETHERTYPE]);
623
624	if (data[IFLA_BAREUDP_SRCPORT_MIN])
625		conf->sport_min =  nla_get_u16(data[IFLA_BAREUDP_SRCPORT_MIN]);
626
627	if (data[IFLA_BAREUDP_MULTIPROTO_MODE])
628		conf->multi_proto_mode = true;
629
630	return 0;
631}
632
633static struct bareudp_dev *bareudp_find_dev(struct bareudp_net *bn,
634					    const struct bareudp_conf *conf)
635{
636	struct bareudp_dev *bareudp, *t = NULL;
637
638	list_for_each_entry(bareudp, &bn->bareudp_list, next) {
639		if (conf->port == bareudp->port)
640			t = bareudp;
641	}
642	return t;
643}
644
645static int bareudp_configure(struct net *net, struct net_device *dev,
646			     struct bareudp_conf *conf,
647			     struct netlink_ext_ack *extack)
648{
649	struct bareudp_net *bn = net_generic(net, bareudp_net_id);
650	struct bareudp_dev *t, *bareudp = netdev_priv(dev);
651	int err;
652
653	bareudp->net = net;
654	bareudp->dev = dev;
655	t = bareudp_find_dev(bn, conf);
656	if (t) {
657		NL_SET_ERR_MSG(extack, "Another bareudp device using the same port already exists");
658		return -EBUSY;
659	}
660
661	if (conf->multi_proto_mode &&
662	    (conf->ethertype != htons(ETH_P_MPLS_UC) &&
663	     conf->ethertype != htons(ETH_P_IP))) {
664		NL_SET_ERR_MSG(extack, "Cannot set multiproto mode for this ethertype (only IPv4 and unicast MPLS are supported)");
665		return -EINVAL;
666	}
667
668	bareudp->port = conf->port;
669	bareudp->ethertype = conf->ethertype;
670	bareudp->sport_min = conf->sport_min;
671	bareudp->multi_proto_mode = conf->multi_proto_mode;
672
673	err = register_netdevice(dev);
674	if (err)
675		return err;
676
677	list_add(&bareudp->next, &bn->bareudp_list);
678	return 0;
679}
680
681static int bareudp_link_config(struct net_device *dev,
682			       struct nlattr *tb[])
683{
684	int err;
685
686	if (tb[IFLA_MTU]) {
687		err = dev_set_mtu(dev, nla_get_u32(tb[IFLA_MTU]));
688		if (err)
689			return err;
690	}
691	return 0;
692}
693
694static void bareudp_dellink(struct net_device *dev, struct list_head *head)
695{
696	struct bareudp_dev *bareudp = netdev_priv(dev);
697
698	list_del(&bareudp->next);
699	unregister_netdevice_queue(dev, head);
700}
701
702static int bareudp_newlink(struct net_device *dev,
703			   struct rtnl_newlink_params *params,
704			   struct netlink_ext_ack *extack)
705{
706	struct net *link_net = rtnl_newlink_link_net(params);
707	struct nlattr **data = params->data;
708	struct nlattr **tb = params->tb;
709	struct bareudp_conf conf;
710	int err;
711
712	err = bareudp2info(data, &conf, extack);
713	if (err)
714		return err;
715
716	err = bareudp_configure(link_net, dev, &conf, extack);
717	if (err)
718		return err;
719
720	err = bareudp_link_config(dev, tb);
721	if (err)
722		goto err_unconfig;
723
724	return 0;
725
726err_unconfig:
727	bareudp_dellink(dev, NULL);
728	return err;
729}
730
731static size_t bareudp_get_size(const struct net_device *dev)
732{
733	return  nla_total_size(sizeof(__be16)) +  /* IFLA_BAREUDP_PORT */
734		nla_total_size(sizeof(__be16)) +  /* IFLA_BAREUDP_ETHERTYPE */
735		nla_total_size(sizeof(__u16))  +  /* IFLA_BAREUDP_SRCPORT_MIN */
736		nla_total_size(0)              +  /* IFLA_BAREUDP_MULTIPROTO_MODE */
737		0;
738}
739
740static int bareudp_fill_info(struct sk_buff *skb, const struct net_device *dev)
741{
742	struct bareudp_dev *bareudp = netdev_priv(dev);
743
744	if (nla_put_be16(skb, IFLA_BAREUDP_PORT, bareudp->port))
745		goto nla_put_failure;
746	if (nla_put_be16(skb, IFLA_BAREUDP_ETHERTYPE, bareudp->ethertype))
747		goto nla_put_failure;
748	if (nla_put_u16(skb, IFLA_BAREUDP_SRCPORT_MIN, bareudp->sport_min))
749		goto nla_put_failure;
750	if (bareudp->multi_proto_mode &&
751	    nla_put_flag(skb, IFLA_BAREUDP_MULTIPROTO_MODE))
752		goto nla_put_failure;
753
754	return 0;
755
756nla_put_failure:
757	return -EMSGSIZE;
758}
759
760static struct rtnl_link_ops bareudp_link_ops __read_mostly = {
761	.kind           = "bareudp",
762	.maxtype        = IFLA_BAREUDP_MAX,
763	.policy         = bareudp_policy,
764	.priv_size      = sizeof(struct bareudp_dev),
765	.setup          = bareudp_setup,
766	.validate       = bareudp_validate,
767	.newlink        = bareudp_newlink,
768	.dellink        = bareudp_dellink,
769	.get_size       = bareudp_get_size,
770	.fill_info      = bareudp_fill_info,
771};
772
773static __net_init int bareudp_init_net(struct net *net)
774{
775	struct bareudp_net *bn = net_generic(net, bareudp_net_id);
776
777	INIT_LIST_HEAD(&bn->bareudp_list);
778	return 0;
779}
780
781static void __net_exit bareudp_exit_rtnl_net(struct net *net,
782					     struct list_head *dev_kill_list)
783{
784	struct bareudp_net *bn = net_generic(net, bareudp_net_id);
785	struct bareudp_dev *bareudp, *next;
786
787	list_for_each_entry_safe(bareudp, next, &bn->bareudp_list, next)
788		bareudp_dellink(bareudp->dev, dev_kill_list);
789}
790
791static struct pernet_operations bareudp_net_ops = {
792	.init = bareudp_init_net,
793	.exit_rtnl = bareudp_exit_rtnl_net,
794	.id   = &bareudp_net_id,
795	.size = sizeof(struct bareudp_net),
796};
797
798static int __init bareudp_init_module(void)
799{
800	int rc;
801
802	rc = register_pernet_subsys(&bareudp_net_ops);
803	if (rc)
804		goto out1;
805
806	rc = rtnl_link_register(&bareudp_link_ops);
807	if (rc)
808		goto out2;
809
810	return 0;
811out2:
812	unregister_pernet_subsys(&bareudp_net_ops);
813out1:
814	return rc;
815}
816late_initcall(bareudp_init_module);
817
818static void __exit bareudp_cleanup_module(void)
819{
820	rtnl_link_unregister(&bareudp_link_ops);
821	unregister_pernet_subsys(&bareudp_net_ops);
822}
823module_exit(bareudp_cleanup_module);
824
825MODULE_ALIAS_RTNL_LINK("bareudp");
826MODULE_LICENSE("GPL");
827MODULE_AUTHOR("Martin Varghese <martin.varghese@nokia.com>");
828MODULE_DESCRIPTION("Interface driver for UDP encapsulated traffic");