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