KVM: emulator: emulate SALC
[firefly-linux-kernel-4.4.55.git] / net / ipv4 / gre.c
1 /*
2  *      GRE over IPv4 demultiplexer driver
3  *
4  *      Authors: Dmitry Kozlov (xeb@mail.ru)
5  *
6  *      This program is free software; you can redistribute it and/or
7  *      modify it under the terms of the GNU General Public License
8  *      as published by the Free Software Foundation; either version
9  *      2 of the License, or (at your option) any later version.
10  *
11  */
12
13 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
14
15 #include <linux/module.h>
16 #include <linux/kernel.h>
17 #include <linux/kmod.h>
18 #include <linux/skbuff.h>
19 #include <linux/in.h>
20 #include <linux/ip.h>
21 #include <linux/netdevice.h>
22 #include <linux/if_tunnel.h>
23 #include <linux/spinlock.h>
24 #include <net/protocol.h>
25 #include <net/gre.h>
26
27
28 static const struct gre_protocol __rcu *gre_proto[GREPROTO_MAX] __read_mostly;
29 static DEFINE_SPINLOCK(gre_proto_lock);
30
31 int gre_add_protocol(const struct gre_protocol *proto, u8 version)
32 {
33         if (version >= GREPROTO_MAX)
34                 goto err_out;
35
36         spin_lock(&gre_proto_lock);
37         if (gre_proto[version])
38                 goto err_out_unlock;
39
40         RCU_INIT_POINTER(gre_proto[version], proto);
41         spin_unlock(&gre_proto_lock);
42         return 0;
43
44 err_out_unlock:
45         spin_unlock(&gre_proto_lock);
46 err_out:
47         return -1;
48 }
49 EXPORT_SYMBOL_GPL(gre_add_protocol);
50
51 int gre_del_protocol(const struct gre_protocol *proto, u8 version)
52 {
53         if (version >= GREPROTO_MAX)
54                 goto err_out;
55
56         spin_lock(&gre_proto_lock);
57         if (rcu_dereference_protected(gre_proto[version],
58                         lockdep_is_held(&gre_proto_lock)) != proto)
59                 goto err_out_unlock;
60         RCU_INIT_POINTER(gre_proto[version], NULL);
61         spin_unlock(&gre_proto_lock);
62         synchronize_rcu();
63         return 0;
64
65 err_out_unlock:
66         spin_unlock(&gre_proto_lock);
67 err_out:
68         return -1;
69 }
70 EXPORT_SYMBOL_GPL(gre_del_protocol);
71
72 static int gre_rcv(struct sk_buff *skb)
73 {
74         const struct gre_protocol *proto;
75         u8 ver;
76         int ret;
77
78         if (!pskb_may_pull(skb, 12))
79                 goto drop;
80
81         ver = skb->data[1]&0x7f;
82         if (ver >= GREPROTO_MAX)
83                 goto drop;
84
85         rcu_read_lock();
86         proto = rcu_dereference(gre_proto[ver]);
87         if (!proto || !proto->handler)
88                 goto drop_unlock;
89         ret = proto->handler(skb);
90         rcu_read_unlock();
91         return ret;
92
93 drop_unlock:
94         rcu_read_unlock();
95 drop:
96         kfree_skb(skb);
97         return NET_RX_DROP;
98 }
99
100 static void gre_err(struct sk_buff *skb, u32 info)
101 {
102         const struct gre_protocol *proto;
103         const struct iphdr *iph = (const struct iphdr *)skb->data;
104         u8 ver = skb->data[(iph->ihl<<2) + 1]&0x7f;
105
106         if (ver >= GREPROTO_MAX)
107                 return;
108
109         rcu_read_lock();
110         proto = rcu_dereference(gre_proto[ver]);
111         if (proto && proto->err_handler)
112                 proto->err_handler(skb, info);
113         rcu_read_unlock();
114 }
115
116 static struct sk_buff *gre_gso_segment(struct sk_buff *skb,
117                                        netdev_features_t features)
118 {
119         struct sk_buff *segs = ERR_PTR(-EINVAL);
120         netdev_features_t enc_features;
121         int ghl = GRE_HEADER_SECTION;
122         struct gre_base_hdr *greh;
123         int mac_len = skb->mac_len;
124         __be16 protocol = skb->protocol;
125         int tnl_hlen;
126         bool csum;
127
128         if (unlikely(skb_shinfo(skb)->gso_type &
129                                 ~(SKB_GSO_TCPV4 |
130                                   SKB_GSO_TCPV6 |
131                                   SKB_GSO_UDP |
132                                   SKB_GSO_DODGY |
133                                   SKB_GSO_TCP_ECN |
134                                   SKB_GSO_GRE)))
135                 goto out;
136
137         if (unlikely(!pskb_may_pull(skb, sizeof(*greh))))
138                 goto out;
139
140         greh = (struct gre_base_hdr *)skb_transport_header(skb);
141
142         if (greh->flags & GRE_KEY)
143                 ghl += GRE_HEADER_SECTION;
144         if (greh->flags & GRE_SEQ)
145                 ghl += GRE_HEADER_SECTION;
146         if (greh->flags & GRE_CSUM) {
147                 ghl += GRE_HEADER_SECTION;
148                 csum = true;
149         } else
150                 csum = false;
151
152         /* setup inner skb. */
153         if (greh->protocol == htons(ETH_P_TEB)) {
154                 struct ethhdr *eth = (struct ethhdr *)skb_inner_mac_header(skb);
155                 skb->protocol = eth->h_proto;
156         } else {
157                 skb->protocol = greh->protocol;
158         }
159
160         skb->encapsulation = 0;
161
162         if (unlikely(!pskb_may_pull(skb, ghl)))
163                 goto out;
164         __skb_pull(skb, ghl);
165         skb_reset_mac_header(skb);
166         skb_set_network_header(skb, skb_inner_network_offset(skb));
167         skb->mac_len = skb_inner_network_offset(skb);
168
169         /* segment inner packet. */
170         enc_features = skb->dev->hw_enc_features & netif_skb_features(skb);
171         segs = skb_mac_gso_segment(skb, enc_features);
172         if (!segs || IS_ERR(segs))
173                 goto out;
174
175         skb = segs;
176         tnl_hlen = skb_tnl_header_len(skb);
177         do {
178                 __skb_push(skb, ghl);
179                 if (csum) {
180                         __be32 *pcsum;
181
182                         if (skb_has_shared_frag(skb)) {
183                                 int err;
184
185                                 err = __skb_linearize(skb);
186                                 if (err) {
187                                         kfree_skb(segs);
188                                         segs = ERR_PTR(err);
189                                         goto out;
190                                 }
191                         }
192
193                         greh = (struct gre_base_hdr *)(skb->data);
194                         pcsum = (__be32 *)(greh + 1);
195                         *pcsum = 0;
196                         *(__sum16 *)pcsum = csum_fold(skb_checksum(skb, 0, skb->len, 0));
197                 }
198                 __skb_push(skb, tnl_hlen - ghl);
199
200                 skb_reset_mac_header(skb);
201                 skb_set_network_header(skb, mac_len);
202                 skb->mac_len = mac_len;
203                 skb->protocol = protocol;
204         } while ((skb = skb->next));
205 out:
206         return segs;
207 }
208
209 static int gre_gso_send_check(struct sk_buff *skb)
210 {
211         if (!skb->encapsulation)
212                 return -EINVAL;
213         return 0;
214 }
215
216 static const struct net_protocol net_gre_protocol = {
217         .handler     = gre_rcv,
218         .err_handler = gre_err,
219         .netns_ok    = 1,
220 };
221
222 static const struct net_offload gre_offload = {
223         .callbacks = {
224                 .gso_send_check =       gre_gso_send_check,
225                 .gso_segment    =       gre_gso_segment,
226         },
227 };
228
229 static int __init gre_init(void)
230 {
231         pr_info("GRE over IPv4 demultiplexor driver\n");
232
233         if (inet_add_protocol(&net_gre_protocol, IPPROTO_GRE) < 0) {
234                 pr_err("can't add protocol\n");
235                 return -EAGAIN;
236         }
237
238         if (inet_add_offload(&gre_offload, IPPROTO_GRE)) {
239                 pr_err("can't add protocol offload\n");
240                 inet_del_protocol(&net_gre_protocol, IPPROTO_GRE);
241                 return -EAGAIN;
242         }
243
244         return 0;
245 }
246
247 static void __exit gre_exit(void)
248 {
249         inet_del_offload(&gre_offload, IPPROTO_GRE);
250         inet_del_protocol(&net_gre_protocol, IPPROTO_GRE);
251 }
252
253 module_init(gre_init);
254 module_exit(gre_exit);
255
256 MODULE_DESCRIPTION("GRE over IPv4 demultiplexer driver");
257 MODULE_AUTHOR("D. Kozlov (xeb@mail.ru)");
258 MODULE_LICENSE("GPL");
259