1 | /* SPDX-License-Identifier: GPL-2.0 */ |
2 | #ifndef __NET_UDP_TUNNEL_H |
3 | #define __NET_UDP_TUNNEL_H |
4 | |
5 | #include <net/ip_tunnels.h> |
6 | #include <net/udp.h> |
7 | |
8 | #if IS_ENABLED(CONFIG_IPV6) |
9 | #include <net/ipv6.h> |
10 | #include <net/ipv6_stubs.h> |
11 | #endif |
12 | |
13 | struct udp_port_cfg { |
14 | u8 family; |
15 | |
16 | /* Used only for kernel-created sockets */ |
17 | union { |
18 | struct in_addr local_ip; |
19 | #if IS_ENABLED(CONFIG_IPV6) |
20 | struct in6_addr local_ip6; |
21 | #endif |
22 | }; |
23 | |
24 | union { |
25 | struct in_addr peer_ip; |
26 | #if IS_ENABLED(CONFIG_IPV6) |
27 | struct in6_addr peer_ip6; |
28 | #endif |
29 | }; |
30 | |
31 | __be16 local_udp_port; |
32 | __be16 peer_udp_port; |
33 | int bind_ifindex; |
34 | unsigned int use_udp_checksums:1, |
35 | use_udp6_tx_checksums:1, |
36 | use_udp6_rx_checksums:1, |
37 | ipv6_v6only:1; |
38 | }; |
39 | |
40 | int udp_sock_create4(struct net *net, struct udp_port_cfg *cfg, |
41 | struct socket **sockp); |
42 | |
43 | #if IS_ENABLED(CONFIG_IPV6) |
44 | int udp_sock_create6(struct net *net, struct udp_port_cfg *cfg, |
45 | struct socket **sockp); |
46 | #else |
47 | static inline int udp_sock_create6(struct net *net, struct udp_port_cfg *cfg, |
48 | struct socket **sockp) |
49 | { |
50 | return 0; |
51 | } |
52 | #endif |
53 | |
54 | static inline int udp_sock_create(struct net *net, |
55 | struct udp_port_cfg *cfg, |
56 | struct socket **sockp) |
57 | { |
58 | if (cfg->family == AF_INET) |
59 | return udp_sock_create4(net, cfg, sockp); |
60 | |
61 | if (cfg->family == AF_INET6) |
62 | return udp_sock_create6(net, cfg, sockp); |
63 | |
64 | return -EPFNOSUPPORT; |
65 | } |
66 | |
67 | typedef int (*udp_tunnel_encap_rcv_t)(struct sock *sk, struct sk_buff *skb); |
68 | typedef int (*udp_tunnel_encap_err_lookup_t)(struct sock *sk, |
69 | struct sk_buff *skb); |
70 | typedef void (*udp_tunnel_encap_destroy_t)(struct sock *sk); |
71 | typedef struct sk_buff *(*udp_tunnel_gro_receive_t)(struct sock *sk, |
72 | struct list_head *head, |
73 | struct sk_buff *skb); |
74 | typedef int (*udp_tunnel_gro_complete_t)(struct sock *sk, struct sk_buff *skb, |
75 | int nhoff); |
76 | |
77 | struct udp_tunnel_sock_cfg { |
78 | void *sk_user_data; /* user data used by encap_rcv call back */ |
79 | /* Used for setting up udp_sock fields, see udp.h for details */ |
80 | __u8 encap_type; |
81 | udp_tunnel_encap_rcv_t encap_rcv; |
82 | udp_tunnel_encap_err_lookup_t encap_err_lookup; |
83 | udp_tunnel_encap_destroy_t encap_destroy; |
84 | udp_tunnel_gro_receive_t gro_receive; |
85 | udp_tunnel_gro_complete_t gro_complete; |
86 | }; |
87 | |
88 | /* Setup the given (UDP) sock to receive UDP encapsulated packets */ |
89 | void setup_udp_tunnel_sock(struct net *net, struct socket *sock, |
90 | struct udp_tunnel_sock_cfg *sock_cfg); |
91 | |
92 | /* -- List of parsable UDP tunnel types -- |
93 | * |
94 | * Adding to this list will result in serious debate. The main issue is |
95 | * that this list is essentially a list of workarounds for either poorly |
96 | * designed tunnels, or poorly designed device offloads. |
97 | * |
98 | * The parsing supported via these types should really be used for Rx |
99 | * traffic only as the network stack will have already inserted offsets for |
100 | * the location of the headers in the skb. In addition any ports that are |
101 | * pushed should be kept within the namespace without leaking to other |
102 | * devices such as VFs or other ports on the same device. |
103 | * |
104 | * It is strongly encouraged to use CHECKSUM_COMPLETE for Rx to avoid the |
105 | * need to use this for Rx checksum offload. It should not be necessary to |
106 | * call this function to perform Tx offloads on outgoing traffic. |
107 | */ |
108 | enum udp_parsable_tunnel_type { |
109 | UDP_TUNNEL_TYPE_VXLAN = BIT(0), /* RFC 7348 */ |
110 | UDP_TUNNEL_TYPE_GENEVE = BIT(1), /* draft-ietf-nvo3-geneve */ |
111 | UDP_TUNNEL_TYPE_VXLAN_GPE = BIT(2), /* draft-ietf-nvo3-vxlan-gpe */ |
112 | }; |
113 | |
114 | struct udp_tunnel_info { |
115 | unsigned short type; |
116 | sa_family_t sa_family; |
117 | __be16 port; |
118 | u8 hw_priv; |
119 | }; |
120 | |
121 | /* Notify network devices of offloadable types */ |
122 | void udp_tunnel_push_rx_port(struct net_device *dev, struct socket *sock, |
123 | unsigned short type); |
124 | void udp_tunnel_drop_rx_port(struct net_device *dev, struct socket *sock, |
125 | unsigned short type); |
126 | void udp_tunnel_notify_add_rx_port(struct socket *sock, unsigned short type); |
127 | void udp_tunnel_notify_del_rx_port(struct socket *sock, unsigned short type); |
128 | |
129 | static inline void udp_tunnel_get_rx_info(struct net_device *dev) |
130 | { |
131 | ASSERT_RTNL(); |
132 | if (!(dev->features & NETIF_F_RX_UDP_TUNNEL_PORT)) |
133 | return; |
134 | call_netdevice_notifiers(NETDEV_UDP_TUNNEL_PUSH_INFO, dev); |
135 | } |
136 | |
137 | static inline void udp_tunnel_drop_rx_info(struct net_device *dev) |
138 | { |
139 | ASSERT_RTNL(); |
140 | if (!(dev->features & NETIF_F_RX_UDP_TUNNEL_PORT)) |
141 | return; |
142 | call_netdevice_notifiers(NETDEV_UDP_TUNNEL_DROP_INFO, dev); |
143 | } |
144 | |
145 | /* Transmit the skb using UDP encapsulation. */ |
146 | void udp_tunnel_xmit_skb(struct rtable *rt, struct sock *sk, struct sk_buff *skb, |
147 | __be32 src, __be32 dst, __u8 tos, __u8 ttl, |
148 | __be16 df, __be16 src_port, __be16 dst_port, |
149 | bool xnet, bool nocheck); |
150 | |
151 | int udp_tunnel6_xmit_skb(struct dst_entry *dst, struct sock *sk, |
152 | struct sk_buff *skb, |
153 | struct net_device *dev, struct in6_addr *saddr, |
154 | struct in6_addr *daddr, |
155 | __u8 prio, __u8 ttl, __be32 label, |
156 | __be16 src_port, __be16 dst_port, bool nocheck); |
157 | |
158 | void udp_tunnel_sock_release(struct socket *sock); |
159 | |
160 | struct metadata_dst *udp_tun_rx_dst(struct sk_buff *skb, unsigned short family, |
161 | __be16 flags, __be64 tunnel_id, |
162 | int md_size); |
163 | |
164 | #ifdef CONFIG_INET |
165 | static inline int udp_tunnel_handle_offloads(struct sk_buff *skb, bool udp_csum) |
166 | { |
167 | int type = udp_csum ? SKB_GSO_UDP_TUNNEL_CSUM : SKB_GSO_UDP_TUNNEL; |
168 | |
169 | return iptunnel_handle_offloads(skb, type); |
170 | } |
171 | #endif |
172 | |
173 | static inline void udp_tunnel_encap_enable(struct socket *sock) |
174 | { |
175 | struct udp_sock *up = udp_sk(sock->sk); |
176 | |
177 | if (up->encap_enabled) |
178 | return; |
179 | |
180 | up->encap_enabled = 1; |
181 | #if IS_ENABLED(CONFIG_IPV6) |
182 | if (sock->sk->sk_family == PF_INET6) |
183 | ipv6_stub->udpv6_encap_enable(); |
184 | #endif |
185 | udp_encap_enable(); |
186 | } |
187 | |
188 | #define UDP_TUNNEL_NIC_MAX_TABLES 4 |
189 | |
190 | enum udp_tunnel_nic_info_flags { |
191 | /* Device callbacks may sleep */ |
192 | UDP_TUNNEL_NIC_INFO_MAY_SLEEP = BIT(0), |
193 | /* Device only supports offloads when it's open, all ports |
194 | * will be removed before close and re-added after open. |
195 | */ |
196 | UDP_TUNNEL_NIC_INFO_OPEN_ONLY = BIT(1), |
197 | /* Device supports only IPv4 tunnels */ |
198 | UDP_TUNNEL_NIC_INFO_IPV4_ONLY = BIT(2), |
199 | /* Device has hard-coded the IANA VXLAN port (4789) as VXLAN. |
200 | * This port must not be counted towards n_entries of any table. |
201 | * Driver will not receive any callback associated with port 4789. |
202 | */ |
203 | UDP_TUNNEL_NIC_INFO_STATIC_IANA_VXLAN = BIT(3), |
204 | }; |
205 | |
206 | struct udp_tunnel_nic; |
207 | |
208 | #define UDP_TUNNEL_NIC_MAX_SHARING_DEVICES (U16_MAX / 2) |
209 | |
210 | struct udp_tunnel_nic_shared { |
211 | struct udp_tunnel_nic *udp_tunnel_nic_info; |
212 | |
213 | struct list_head devices; |
214 | }; |
215 | |
216 | struct udp_tunnel_nic_shared_node { |
217 | struct net_device *dev; |
218 | struct list_head list; |
219 | }; |
220 | |
221 | /** |
222 | * struct udp_tunnel_nic_info - driver UDP tunnel offload information |
223 | * @set_port: callback for adding a new port |
224 | * @unset_port: callback for removing a port |
225 | * @sync_table: callback for syncing the entire port table at once |
226 | * @shared: reference to device global state (optional) |
227 | * @flags: device flags from enum udp_tunnel_nic_info_flags |
228 | * @tables: UDP port tables this device has |
229 | * @tables.n_entries: number of entries in this table |
230 | * @tables.tunnel_types: types of tunnels this table accepts |
231 | * |
232 | * Drivers are expected to provide either @set_port and @unset_port callbacks |
233 | * or the @sync_table callback. Callbacks are invoked with rtnl lock held. |
234 | * |
235 | * Devices which (misguidedly) share the UDP tunnel port table across multiple |
236 | * netdevs should allocate an instance of struct udp_tunnel_nic_shared and |
237 | * point @shared at it. |
238 | * There must never be more than %UDP_TUNNEL_NIC_MAX_SHARING_DEVICES devices |
239 | * sharing a table. |
240 | * |
241 | * Known limitations: |
242 | * - UDP tunnel port notifications are fundamentally best-effort - |
243 | * it is likely the driver will both see skbs which use a UDP tunnel port, |
244 | * while not being a tunneled skb, and tunnel skbs from other ports - |
245 | * drivers should only use these ports for non-critical RX-side offloads, |
246 | * e.g. the checksum offload; |
247 | * - none of the devices care about the socket family at present, so we don't |
248 | * track it. Please extend this code if you care. |
249 | */ |
250 | struct udp_tunnel_nic_info { |
251 | /* one-by-one */ |
252 | int (*set_port)(struct net_device *dev, |
253 | unsigned int table, unsigned int entry, |
254 | struct udp_tunnel_info *ti); |
255 | int (*unset_port)(struct net_device *dev, |
256 | unsigned int table, unsigned int entry, |
257 | struct udp_tunnel_info *ti); |
258 | |
259 | /* all at once */ |
260 | int (*sync_table)(struct net_device *dev, unsigned int table); |
261 | |
262 | struct udp_tunnel_nic_shared *shared; |
263 | |
264 | unsigned int flags; |
265 | |
266 | struct udp_tunnel_nic_table_info { |
267 | unsigned int n_entries; |
268 | unsigned int tunnel_types; |
269 | } tables[UDP_TUNNEL_NIC_MAX_TABLES]; |
270 | }; |
271 | |
272 | /* UDP tunnel module dependencies |
273 | * |
274 | * Tunnel drivers are expected to have a hard dependency on the udp_tunnel |
275 | * module. NIC drivers are not, they just attach their |
276 | * struct udp_tunnel_nic_info to the netdev and wait for callbacks to come. |
277 | * Loading a tunnel driver will cause the udp_tunnel module to be loaded |
278 | * and only then will all the required state structures be allocated. |
279 | * Since we want a weak dependency from the drivers and the core to udp_tunnel |
280 | * we call things through the following stubs. |
281 | */ |
282 | struct udp_tunnel_nic_ops { |
283 | void (*get_port)(struct net_device *dev, unsigned int table, |
284 | unsigned int idx, struct udp_tunnel_info *ti); |
285 | void (*set_port_priv)(struct net_device *dev, unsigned int table, |
286 | unsigned int idx, u8 priv); |
287 | void (*add_port)(struct net_device *dev, struct udp_tunnel_info *ti); |
288 | void (*del_port)(struct net_device *dev, struct udp_tunnel_info *ti); |
289 | void (*reset_ntf)(struct net_device *dev); |
290 | |
291 | size_t (*dump_size)(struct net_device *dev, unsigned int table); |
292 | int (*dump_write)(struct net_device *dev, unsigned int table, |
293 | struct sk_buff *skb); |
294 | }; |
295 | |
296 | #ifdef CONFIG_INET |
297 | extern const struct udp_tunnel_nic_ops *udp_tunnel_nic_ops; |
298 | #else |
299 | #define udp_tunnel_nic_ops ((struct udp_tunnel_nic_ops *)NULL) |
300 | #endif |
301 | |
302 | static inline void |
303 | udp_tunnel_nic_get_port(struct net_device *dev, unsigned int table, |
304 | unsigned int idx, struct udp_tunnel_info *ti) |
305 | { |
306 | /* This helper is used from .sync_table, we indicate empty entries |
307 | * by zero'ed @ti. Drivers which need to know the details of a port |
308 | * when it gets deleted should use the .set_port / .unset_port |
309 | * callbacks. |
310 | * Zero out here, otherwise !CONFIG_INET causes uninitilized warnings. |
311 | */ |
312 | memset(ti, 0, sizeof(*ti)); |
313 | |
314 | if (udp_tunnel_nic_ops) |
315 | udp_tunnel_nic_ops->get_port(dev, table, idx, ti); |
316 | } |
317 | |
318 | static inline void |
319 | udp_tunnel_nic_set_port_priv(struct net_device *dev, unsigned int table, |
320 | unsigned int idx, u8 priv) |
321 | { |
322 | if (udp_tunnel_nic_ops) |
323 | udp_tunnel_nic_ops->set_port_priv(dev, table, idx, priv); |
324 | } |
325 | |
326 | static inline void |
327 | udp_tunnel_nic_add_port(struct net_device *dev, struct udp_tunnel_info *ti) |
328 | { |
329 | if (!(dev->features & NETIF_F_RX_UDP_TUNNEL_PORT)) |
330 | return; |
331 | if (udp_tunnel_nic_ops) |
332 | udp_tunnel_nic_ops->add_port(dev, ti); |
333 | } |
334 | |
335 | static inline void |
336 | udp_tunnel_nic_del_port(struct net_device *dev, struct udp_tunnel_info *ti) |
337 | { |
338 | if (!(dev->features & NETIF_F_RX_UDP_TUNNEL_PORT)) |
339 | return; |
340 | if (udp_tunnel_nic_ops) |
341 | udp_tunnel_nic_ops->del_port(dev, ti); |
342 | } |
343 | |
344 | /** |
345 | * udp_tunnel_nic_reset_ntf() - device-originating reset notification |
346 | * @dev: network interface device structure |
347 | * |
348 | * Called by the driver to inform the core that the entire UDP tunnel port |
349 | * state has been lost, usually due to device reset. Core will assume device |
350 | * forgot all the ports and issue .set_port and .sync_table callbacks as |
351 | * necessary. |
352 | * |
353 | * This function must be called with rtnl lock held, and will issue all |
354 | * the callbacks before returning. |
355 | */ |
356 | static inline void udp_tunnel_nic_reset_ntf(struct net_device *dev) |
357 | { |
358 | if (udp_tunnel_nic_ops) |
359 | udp_tunnel_nic_ops->reset_ntf(dev); |
360 | } |
361 | |
362 | static inline size_t |
363 | udp_tunnel_nic_dump_size(struct net_device *dev, unsigned int table) |
364 | { |
365 | if (!udp_tunnel_nic_ops) |
366 | return 0; |
367 | return udp_tunnel_nic_ops->dump_size(dev, table); |
368 | } |
369 | |
370 | static inline int |
371 | udp_tunnel_nic_dump_write(struct net_device *dev, unsigned int table, |
372 | struct sk_buff *skb) |
373 | { |
374 | if (!udp_tunnel_nic_ops) |
375 | return 0; |
376 | return udp_tunnel_nic_ops->dump_write(dev, table, skb); |
377 | } |
378 | #endif |
379 | |