1 #include <linux/module.h>
2 #include <linux/errno.h>
3 #include <linux/socket.h>
4 #include <linux/skbuff.h>
7 #include <linux/types.h>
8 #include <linux/kernel.h>
9 #include <net/genetlink.h>
12 #include <net/protocol.h>
14 #include <net/udp_tunnel.h>
16 #include <uapi/linux/fou.h>
17 #include <uapi/linux/genetlink.h>
25 struct list_head list
;
29 #define FOU_F_REMCSUM_NOPARTIAL BIT(0)
35 struct udp_port_cfg udp_config
;
38 static unsigned int fou_net_id
;
41 struct list_head fou_list
;
42 struct mutex fou_lock
;
45 static inline struct fou
*fou_from_sock(struct sock
*sk
)
47 return sk
->sk_user_data
;
50 static int fou_recv_pull(struct sk_buff
*skb
, size_t len
)
52 struct iphdr
*iph
= ip_hdr(skb
);
54 /* Remove 'len' bytes from the packet (UDP header and
55 * FOU header if present).
57 iph
->tot_len
= htons(ntohs(iph
->tot_len
) - len
);
59 skb_postpull_rcsum(skb
, udp_hdr(skb
), len
);
60 skb_reset_transport_header(skb
);
61 return iptunnel_pull_offloads(skb
);
64 static int fou_udp_recv(struct sock
*sk
, struct sk_buff
*skb
)
66 struct fou
*fou
= fou_from_sock(sk
);
71 if (fou_recv_pull(skb
, sizeof(struct udphdr
)))
74 return -fou
->protocol
;
81 static struct guehdr
*gue_remcsum(struct sk_buff
*skb
, struct guehdr
*guehdr
,
82 void *data
, size_t hdrlen
, u8 ipproto
,
86 size_t start
= ntohs(pd
[0]);
87 size_t offset
= ntohs(pd
[1]);
88 size_t plen
= sizeof(struct udphdr
) + hdrlen
+
89 max_t(size_t, offset
+ sizeof(u16
), start
);
91 if (skb
->remcsum_offload
)
94 if (!pskb_may_pull(skb
, plen
))
96 guehdr
= (struct guehdr
*)&udp_hdr(skb
)[1];
98 skb_remcsum_process(skb
, (void *)guehdr
+ hdrlen
,
99 start
, offset
, nopartial
);
104 static int gue_control_message(struct sk_buff
*skb
, struct guehdr
*guehdr
)
111 static int gue_udp_recv(struct sock
*sk
, struct sk_buff
*skb
)
113 struct fou
*fou
= fou_from_sock(sk
);
114 size_t len
, optlen
, hdrlen
;
115 struct guehdr
*guehdr
;
122 len
= sizeof(struct udphdr
) + sizeof(struct guehdr
);
123 if (!pskb_may_pull(skb
, len
))
126 guehdr
= (struct guehdr
*)&udp_hdr(skb
)[1];
128 optlen
= guehdr
->hlen
<< 2;
131 if (!pskb_may_pull(skb
, len
))
134 /* guehdr may change after pull */
135 guehdr
= (struct guehdr
*)&udp_hdr(skb
)[1];
137 hdrlen
= sizeof(struct guehdr
) + optlen
;
139 if (guehdr
->version
!= 0 || validate_gue_flags(guehdr
, optlen
))
142 hdrlen
= sizeof(struct guehdr
) + optlen
;
144 ip_hdr(skb
)->tot_len
= htons(ntohs(ip_hdr(skb
)->tot_len
) - len
);
146 /* Pull csum through the guehdr now . This can be used if
147 * there is a remote checksum offload.
149 skb_postpull_rcsum(skb
, udp_hdr(skb
), len
);
153 if (guehdr
->flags
& GUE_FLAG_PRIV
) {
154 __be32 flags
= *(__be32
*)(data
+ doffset
);
156 doffset
+= GUE_LEN_PRIV
;
158 if (flags
& GUE_PFLAG_REMCSUM
) {
159 guehdr
= gue_remcsum(skb
, guehdr
, data
+ doffset
,
160 hdrlen
, guehdr
->proto_ctype
,
162 FOU_F_REMCSUM_NOPARTIAL
));
168 doffset
+= GUE_PLEN_REMCSUM
;
172 if (unlikely(guehdr
->control
))
173 return gue_control_message(skb
, guehdr
);
175 __skb_pull(skb
, sizeof(struct udphdr
) + hdrlen
);
176 skb_reset_transport_header(skb
);
178 if (iptunnel_pull_offloads(skb
))
181 return -guehdr
->proto_ctype
;
188 static struct sk_buff
**fou_gro_receive(struct sock
*sk
,
189 struct sk_buff
**head
,
192 const struct net_offload
*ops
;
193 struct sk_buff
**pp
= NULL
;
194 u8 proto
= fou_from_sock(sk
)->protocol
;
195 const struct net_offload
**offloads
;
197 /* We can clear the encap_mark for FOU as we are essentially doing
198 * one of two possible things. We are either adding an L4 tunnel
199 * header to the outer L3 tunnel header, or we are are simply
200 * treating the GRE tunnel header as though it is a UDP protocol
201 * specific header such as VXLAN or GENEVE.
203 NAPI_GRO_CB(skb
)->encap_mark
= 0;
205 /* Flag this frame as already having an outer encap header */
206 NAPI_GRO_CB(skb
)->is_fou
= 1;
209 offloads
= NAPI_GRO_CB(skb
)->is_ipv6
? inet6_offloads
: inet_offloads
;
210 ops
= rcu_dereference(offloads
[proto
]);
211 if (!ops
|| !ops
->callbacks
.gro_receive
)
214 pp
= ops
->callbacks
.gro_receive(head
, skb
);
222 static int fou_gro_complete(struct sock
*sk
, struct sk_buff
*skb
,
225 const struct net_offload
*ops
;
226 u8 proto
= fou_from_sock(sk
)->protocol
;
228 const struct net_offload
**offloads
;
231 offloads
= NAPI_GRO_CB(skb
)->is_ipv6
? inet6_offloads
: inet_offloads
;
232 ops
= rcu_dereference(offloads
[proto
]);
233 if (WARN_ON(!ops
|| !ops
->callbacks
.gro_complete
))
236 err
= ops
->callbacks
.gro_complete(skb
, nhoff
);
238 skb_set_inner_mac_header(skb
, nhoff
);
246 static struct guehdr
*gue_gro_remcsum(struct sk_buff
*skb
, unsigned int off
,
247 struct guehdr
*guehdr
, void *data
,
248 size_t hdrlen
, struct gro_remcsum
*grc
,
252 size_t start
= ntohs(pd
[0]);
253 size_t offset
= ntohs(pd
[1]);
255 if (skb
->remcsum_offload
)
258 if (!NAPI_GRO_CB(skb
)->csum_valid
)
261 guehdr
= skb_gro_remcsum_process(skb
, (void *)guehdr
, off
, hdrlen
,
262 start
, offset
, grc
, nopartial
);
264 skb
->remcsum_offload
= 1;
269 static struct sk_buff
**gue_gro_receive(struct sock
*sk
,
270 struct sk_buff
**head
,
273 const struct net_offload
**offloads
;
274 const struct net_offload
*ops
;
275 struct sk_buff
**pp
= NULL
;
277 struct guehdr
*guehdr
;
278 size_t len
, optlen
, hdrlen
, off
;
282 struct fou
*fou
= fou_from_sock(sk
);
283 struct gro_remcsum grc
;
285 skb_gro_remcsum_init(&grc
);
287 off
= skb_gro_offset(skb
);
288 len
= off
+ sizeof(*guehdr
);
290 guehdr
= skb_gro_header_fast(skb
, off
);
291 if (skb_gro_header_hard(skb
, len
)) {
292 guehdr
= skb_gro_header_slow(skb
, len
, off
);
293 if (unlikely(!guehdr
))
297 optlen
= guehdr
->hlen
<< 2;
300 if (skb_gro_header_hard(skb
, len
)) {
301 guehdr
= skb_gro_header_slow(skb
, len
, off
);
302 if (unlikely(!guehdr
))
306 if (unlikely(guehdr
->control
) || guehdr
->version
!= 0 ||
307 validate_gue_flags(guehdr
, optlen
))
310 hdrlen
= sizeof(*guehdr
) + optlen
;
312 /* Adjust NAPI_GRO_CB(skb)->csum to account for guehdr,
313 * this is needed if there is a remote checkcsum offload.
315 skb_gro_postpull_rcsum(skb
, guehdr
, hdrlen
);
319 if (guehdr
->flags
& GUE_FLAG_PRIV
) {
320 __be32 flags
= *(__be32
*)(data
+ doffset
);
322 doffset
+= GUE_LEN_PRIV
;
324 if (flags
& GUE_PFLAG_REMCSUM
) {
325 guehdr
= gue_gro_remcsum(skb
, off
, guehdr
,
326 data
+ doffset
, hdrlen
, &grc
,
328 FOU_F_REMCSUM_NOPARTIAL
));
335 doffset
+= GUE_PLEN_REMCSUM
;
339 skb_gro_pull(skb
, hdrlen
);
341 for (p
= *head
; p
; p
= p
->next
) {
342 const struct guehdr
*guehdr2
;
344 if (!NAPI_GRO_CB(p
)->same_flow
)
347 guehdr2
= (struct guehdr
*)(p
->data
+ off
);
349 /* Compare base GUE header to be equal (covers
350 * hlen, version, proto_ctype, and flags.
352 if (guehdr
->word
!= guehdr2
->word
) {
353 NAPI_GRO_CB(p
)->same_flow
= 0;
357 /* Compare optional fields are the same. */
358 if (guehdr
->hlen
&& memcmp(&guehdr
[1], &guehdr2
[1],
359 guehdr
->hlen
<< 2)) {
360 NAPI_GRO_CB(p
)->same_flow
= 0;
365 /* We can clear the encap_mark for GUE as we are essentially doing
366 * one of two possible things. We are either adding an L4 tunnel
367 * header to the outer L3 tunnel header, or we are are simply
368 * treating the GRE tunnel header as though it is a UDP protocol
369 * specific header such as VXLAN or GENEVE.
371 NAPI_GRO_CB(skb
)->encap_mark
= 0;
373 /* Flag this frame as already having an outer encap header */
374 NAPI_GRO_CB(skb
)->is_fou
= 1;
377 offloads
= NAPI_GRO_CB(skb
)->is_ipv6
? inet6_offloads
: inet_offloads
;
378 ops
= rcu_dereference(offloads
[guehdr
->proto_ctype
]);
379 if (WARN_ON_ONCE(!ops
|| !ops
->callbacks
.gro_receive
))
382 pp
= ops
->callbacks
.gro_receive(head
, skb
);
388 NAPI_GRO_CB(skb
)->flush
|= flush
;
389 skb_gro_remcsum_cleanup(skb
, &grc
);
394 static int gue_gro_complete(struct sock
*sk
, struct sk_buff
*skb
, int nhoff
)
396 const struct net_offload
**offloads
;
397 struct guehdr
*guehdr
= (struct guehdr
*)(skb
->data
+ nhoff
);
398 const struct net_offload
*ops
;
399 unsigned int guehlen
;
403 proto
= guehdr
->proto_ctype
;
405 guehlen
= sizeof(*guehdr
) + (guehdr
->hlen
<< 2);
408 offloads
= NAPI_GRO_CB(skb
)->is_ipv6
? inet6_offloads
: inet_offloads
;
409 ops
= rcu_dereference(offloads
[proto
]);
410 if (WARN_ON(!ops
|| !ops
->callbacks
.gro_complete
))
413 err
= ops
->callbacks
.gro_complete(skb
, nhoff
+ guehlen
);
415 skb_set_inner_mac_header(skb
, nhoff
+ guehlen
);
422 static int fou_add_to_port_list(struct net
*net
, struct fou
*fou
)
424 struct fou_net
*fn
= net_generic(net
, fou_net_id
);
427 mutex_lock(&fn
->fou_lock
);
428 list_for_each_entry(fout
, &fn
->fou_list
, list
) {
429 if (fou
->port
== fout
->port
) {
430 mutex_unlock(&fn
->fou_lock
);
435 list_add(&fou
->list
, &fn
->fou_list
);
436 mutex_unlock(&fn
->fou_lock
);
441 static void fou_release(struct fou
*fou
)
443 struct socket
*sock
= fou
->sock
;
445 list_del(&fou
->list
);
446 udp_tunnel_sock_release(sock
);
451 static int fou_encap_init(struct sock
*sk
, struct fou
*fou
, struct fou_cfg
*cfg
)
453 udp_sk(sk
)->encap_rcv
= fou_udp_recv
;
454 udp_sk(sk
)->gro_receive
= fou_gro_receive
;
455 udp_sk(sk
)->gro_complete
= fou_gro_complete
;
456 fou_from_sock(sk
)->protocol
= cfg
->protocol
;
461 static int gue_encap_init(struct sock
*sk
, struct fou
*fou
, struct fou_cfg
*cfg
)
463 udp_sk(sk
)->encap_rcv
= gue_udp_recv
;
464 udp_sk(sk
)->gro_receive
= gue_gro_receive
;
465 udp_sk(sk
)->gro_complete
= gue_gro_complete
;
470 static int fou_create(struct net
*net
, struct fou_cfg
*cfg
,
471 struct socket
**sockp
)
473 struct socket
*sock
= NULL
;
474 struct fou
*fou
= NULL
;
478 /* Open UDP socket */
479 err
= udp_sock_create(net
, &cfg
->udp_config
, &sock
);
483 /* Allocate FOU port structure */
484 fou
= kzalloc(sizeof(*fou
), GFP_KERNEL
);
492 fou
->flags
= cfg
->flags
;
493 fou
->port
= cfg
->udp_config
.local_udp_port
;
495 /* Initial for fou type */
497 case FOU_ENCAP_DIRECT
:
498 err
= fou_encap_init(sk
, fou
, cfg
);
503 err
= gue_encap_init(sk
, fou
, cfg
);
512 fou
->type
= cfg
->type
;
514 udp_sk(sk
)->encap_type
= 1;
517 sk
->sk_user_data
= fou
;
520 inet_inc_convert_csum(sk
);
522 sk
->sk_allocation
= GFP_ATOMIC
;
524 err
= fou_add_to_port_list(net
, fou
);
536 udp_tunnel_sock_release(sock
);
541 static int fou_destroy(struct net
*net
, struct fou_cfg
*cfg
)
543 struct fou_net
*fn
= net_generic(net
, fou_net_id
);
544 __be16 port
= cfg
->udp_config
.local_udp_port
;
548 mutex_lock(&fn
->fou_lock
);
549 list_for_each_entry(fou
, &fn
->fou_list
, list
) {
550 if (fou
->port
== port
) {
556 mutex_unlock(&fn
->fou_lock
);
561 static struct genl_family fou_nl_family
= {
562 .id
= GENL_ID_GENERATE
,
564 .name
= FOU_GENL_NAME
,
565 .version
= FOU_GENL_VERSION
,
566 .maxattr
= FOU_ATTR_MAX
,
570 static struct nla_policy fou_nl_policy
[FOU_ATTR_MAX
+ 1] = {
571 [FOU_ATTR_PORT
] = { .type
= NLA_U16
, },
572 [FOU_ATTR_AF
] = { .type
= NLA_U8
, },
573 [FOU_ATTR_IPPROTO
] = { .type
= NLA_U8
, },
574 [FOU_ATTR_TYPE
] = { .type
= NLA_U8
, },
575 [FOU_ATTR_REMCSUM_NOPARTIAL
] = { .type
= NLA_FLAG
, },
578 static int parse_nl_config(struct genl_info
*info
,
581 memset(cfg
, 0, sizeof(*cfg
));
583 cfg
->udp_config
.family
= AF_INET
;
585 if (info
->attrs
[FOU_ATTR_AF
]) {
586 u8 family
= nla_get_u8(info
->attrs
[FOU_ATTR_AF
]);
588 if (family
!= AF_INET
)
591 cfg
->udp_config
.family
= family
;
594 if (info
->attrs
[FOU_ATTR_PORT
]) {
595 __be16 port
= nla_get_be16(info
->attrs
[FOU_ATTR_PORT
]);
597 cfg
->udp_config
.local_udp_port
= port
;
600 if (info
->attrs
[FOU_ATTR_IPPROTO
])
601 cfg
->protocol
= nla_get_u8(info
->attrs
[FOU_ATTR_IPPROTO
]);
603 if (info
->attrs
[FOU_ATTR_TYPE
])
604 cfg
->type
= nla_get_u8(info
->attrs
[FOU_ATTR_TYPE
]);
606 if (info
->attrs
[FOU_ATTR_REMCSUM_NOPARTIAL
])
607 cfg
->flags
|= FOU_F_REMCSUM_NOPARTIAL
;
612 static int fou_nl_cmd_add_port(struct sk_buff
*skb
, struct genl_info
*info
)
614 struct net
*net
= genl_info_net(info
);
618 err
= parse_nl_config(info
, &cfg
);
622 return fou_create(net
, &cfg
, NULL
);
625 static int fou_nl_cmd_rm_port(struct sk_buff
*skb
, struct genl_info
*info
)
627 struct net
*net
= genl_info_net(info
);
631 err
= parse_nl_config(info
, &cfg
);
635 return fou_destroy(net
, &cfg
);
638 static int fou_fill_info(struct fou
*fou
, struct sk_buff
*msg
)
640 if (nla_put_u8(msg
, FOU_ATTR_AF
, fou
->sock
->sk
->sk_family
) ||
641 nla_put_be16(msg
, FOU_ATTR_PORT
, fou
->port
) ||
642 nla_put_u8(msg
, FOU_ATTR_IPPROTO
, fou
->protocol
) ||
643 nla_put_u8(msg
, FOU_ATTR_TYPE
, fou
->type
))
646 if (fou
->flags
& FOU_F_REMCSUM_NOPARTIAL
)
647 if (nla_put_flag(msg
, FOU_ATTR_REMCSUM_NOPARTIAL
))
652 static int fou_dump_info(struct fou
*fou
, u32 portid
, u32 seq
,
653 u32 flags
, struct sk_buff
*skb
, u8 cmd
)
657 hdr
= genlmsg_put(skb
, portid
, seq
, &fou_nl_family
, flags
, cmd
);
661 if (fou_fill_info(fou
, skb
) < 0)
662 goto nla_put_failure
;
664 genlmsg_end(skb
, hdr
);
668 genlmsg_cancel(skb
, hdr
);
672 static int fou_nl_cmd_get_port(struct sk_buff
*skb
, struct genl_info
*info
)
674 struct net
*net
= genl_info_net(info
);
675 struct fou_net
*fn
= net_generic(net
, fou_net_id
);
682 ret
= parse_nl_config(info
, &cfg
);
685 port
= cfg
.udp_config
.local_udp_port
;
689 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
694 mutex_lock(&fn
->fou_lock
);
695 list_for_each_entry(fout
, &fn
->fou_list
, list
) {
696 if (port
== fout
->port
) {
697 ret
= fou_dump_info(fout
, info
->snd_portid
,
698 info
->snd_seq
, 0, msg
,
703 mutex_unlock(&fn
->fou_lock
);
707 return genlmsg_reply(msg
, info
);
714 static int fou_nl_dump(struct sk_buff
*skb
, struct netlink_callback
*cb
)
716 struct net
*net
= sock_net(skb
->sk
);
717 struct fou_net
*fn
= net_generic(net
, fou_net_id
);
721 mutex_lock(&fn
->fou_lock
);
722 list_for_each_entry(fout
, &fn
->fou_list
, list
) {
723 if (idx
++ < cb
->args
[0])
725 ret
= fou_dump_info(fout
, NETLINK_CB(cb
->skb
).portid
,
726 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
,
731 mutex_unlock(&fn
->fou_lock
);
737 static const struct genl_ops fou_nl_ops
[] = {
740 .doit
= fou_nl_cmd_add_port
,
741 .policy
= fou_nl_policy
,
742 .flags
= GENL_ADMIN_PERM
,
746 .doit
= fou_nl_cmd_rm_port
,
747 .policy
= fou_nl_policy
,
748 .flags
= GENL_ADMIN_PERM
,
752 .doit
= fou_nl_cmd_get_port
,
753 .dumpit
= fou_nl_dump
,
754 .policy
= fou_nl_policy
,
758 size_t fou_encap_hlen(struct ip_tunnel_encap
*e
)
760 return sizeof(struct udphdr
);
762 EXPORT_SYMBOL(fou_encap_hlen
);
764 size_t gue_encap_hlen(struct ip_tunnel_encap
*e
)
767 bool need_priv
= false;
769 len
= sizeof(struct udphdr
) + sizeof(struct guehdr
);
771 if (e
->flags
& TUNNEL_ENCAP_FLAG_REMCSUM
) {
772 len
+= GUE_PLEN_REMCSUM
;
776 len
+= need_priv
? GUE_LEN_PRIV
: 0;
780 EXPORT_SYMBOL(gue_encap_hlen
);
782 static void fou_build_udp(struct sk_buff
*skb
, struct ip_tunnel_encap
*e
,
783 struct flowi4
*fl4
, u8
*protocol
, __be16 sport
)
787 skb_push(skb
, sizeof(struct udphdr
));
788 skb_reset_transport_header(skb
);
794 uh
->len
= htons(skb
->len
);
795 udp_set_csum(!(e
->flags
& TUNNEL_ENCAP_FLAG_CSUM
), skb
,
796 fl4
->saddr
, fl4
->daddr
, skb
->len
);
798 *protocol
= IPPROTO_UDP
;
801 int fou_build_header(struct sk_buff
*skb
, struct ip_tunnel_encap
*e
,
802 u8
*protocol
, struct flowi4
*fl4
)
804 int type
= e
->flags
& TUNNEL_ENCAP_FLAG_CSUM
? SKB_GSO_UDP_TUNNEL_CSUM
:
809 err
= iptunnel_handle_offloads(skb
, type
);
813 sport
= e
->sport
? : udp_flow_src_port(dev_net(skb
->dev
),
815 fou_build_udp(skb
, e
, fl4
, protocol
, sport
);
819 EXPORT_SYMBOL(fou_build_header
);
821 int gue_build_header(struct sk_buff
*skb
, struct ip_tunnel_encap
*e
,
822 u8
*protocol
, struct flowi4
*fl4
)
824 int type
= e
->flags
& TUNNEL_ENCAP_FLAG_CSUM
? SKB_GSO_UDP_TUNNEL_CSUM
:
826 struct guehdr
*guehdr
;
827 size_t hdrlen
, optlen
= 0;
830 bool need_priv
= false;
833 if ((e
->flags
& TUNNEL_ENCAP_FLAG_REMCSUM
) &&
834 skb
->ip_summed
== CHECKSUM_PARTIAL
) {
835 optlen
+= GUE_PLEN_REMCSUM
;
836 type
|= SKB_GSO_TUNNEL_REMCSUM
;
840 optlen
+= need_priv
? GUE_LEN_PRIV
: 0;
842 err
= iptunnel_handle_offloads(skb
, type
);
846 /* Get source port (based on flow hash) before skb_push */
847 sport
= e
->sport
? : udp_flow_src_port(dev_net(skb
->dev
),
850 hdrlen
= sizeof(struct guehdr
) + optlen
;
852 skb_push(skb
, hdrlen
);
854 guehdr
= (struct guehdr
*)skb
->data
;
858 guehdr
->hlen
= optlen
>> 2;
860 guehdr
->proto_ctype
= *protocol
;
865 __be32
*flags
= data
;
867 guehdr
->flags
|= GUE_FLAG_PRIV
;
869 data
+= GUE_LEN_PRIV
;
871 if (type
& SKB_GSO_TUNNEL_REMCSUM
) {
872 u16 csum_start
= skb_checksum_start_offset(skb
);
875 if (csum_start
< hdrlen
)
878 csum_start
-= hdrlen
;
879 pd
[0] = htons(csum_start
);
880 pd
[1] = htons(csum_start
+ skb
->csum_offset
);
882 if (!skb_is_gso(skb
)) {
883 skb
->ip_summed
= CHECKSUM_NONE
;
884 skb
->encapsulation
= 0;
887 *flags
|= GUE_PFLAG_REMCSUM
;
888 data
+= GUE_PLEN_REMCSUM
;
893 fou_build_udp(skb
, e
, fl4
, protocol
, sport
);
897 EXPORT_SYMBOL(gue_build_header
);
899 #ifdef CONFIG_NET_FOU_IP_TUNNELS
901 static const struct ip_tunnel_encap_ops fou_iptun_ops
= {
902 .encap_hlen
= fou_encap_hlen
,
903 .build_header
= fou_build_header
,
906 static const struct ip_tunnel_encap_ops gue_iptun_ops
= {
907 .encap_hlen
= gue_encap_hlen
,
908 .build_header
= gue_build_header
,
911 static int ip_tunnel_encap_add_fou_ops(void)
915 ret
= ip_tunnel_encap_add_ops(&fou_iptun_ops
, TUNNEL_ENCAP_FOU
);
917 pr_err("can't add fou ops\n");
921 ret
= ip_tunnel_encap_add_ops(&gue_iptun_ops
, TUNNEL_ENCAP_GUE
);
923 pr_err("can't add gue ops\n");
924 ip_tunnel_encap_del_ops(&fou_iptun_ops
, TUNNEL_ENCAP_FOU
);
931 static void ip_tunnel_encap_del_fou_ops(void)
933 ip_tunnel_encap_del_ops(&fou_iptun_ops
, TUNNEL_ENCAP_FOU
);
934 ip_tunnel_encap_del_ops(&gue_iptun_ops
, TUNNEL_ENCAP_GUE
);
939 static int ip_tunnel_encap_add_fou_ops(void)
944 static void ip_tunnel_encap_del_fou_ops(void)
950 static __net_init
int fou_init_net(struct net
*net
)
952 struct fou_net
*fn
= net_generic(net
, fou_net_id
);
954 INIT_LIST_HEAD(&fn
->fou_list
);
955 mutex_init(&fn
->fou_lock
);
959 static __net_exit
void fou_exit_net(struct net
*net
)
961 struct fou_net
*fn
= net_generic(net
, fou_net_id
);
962 struct fou
*fou
, *next
;
964 /* Close all the FOU sockets */
965 mutex_lock(&fn
->fou_lock
);
966 list_for_each_entry_safe(fou
, next
, &fn
->fou_list
, list
)
968 mutex_unlock(&fn
->fou_lock
);
971 static struct pernet_operations fou_net_ops
= {
972 .init
= fou_init_net
,
973 .exit
= fou_exit_net
,
975 .size
= sizeof(struct fou_net
),
978 static int __init
fou_init(void)
982 ret
= register_pernet_device(&fou_net_ops
);
986 ret
= genl_register_family_with_ops(&fou_nl_family
,
991 ret
= ip_tunnel_encap_add_fou_ops();
995 genl_unregister_family(&fou_nl_family
);
997 unregister_pernet_device(&fou_net_ops
);
1002 static void __exit
fou_fini(void)
1004 ip_tunnel_encap_del_fou_ops();
1005 genl_unregister_family(&fou_nl_family
);
1006 unregister_pernet_device(&fou_net_ops
);
1009 module_init(fou_init
);
1010 module_exit(fou_fini
);
1011 MODULE_AUTHOR("Tom Herbert <therbert@google.com>");
1012 MODULE_LICENSE("GPL");