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