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