Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit ef9a9d1183b36fbf3de327f44596533b770c3005

Authored by Eric Dumazet
Committed by David S. Miller
1 parent b37b62fea1
Exists in master and in 7 other branches imx_3.0.35_4.1.0, imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga, smarc-l5.0.0_1.0.0-ga

ipv6 sit: RCU conversion phase I 

SIT tunnels use one rwlock to protect their prl entries.

This first patch adds RCU locking for prl management,
with standard call_rcu() calls.

Signed-off-by: Eric Dumazet <eric.dumazet@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

Showing 2 changed files with 51 additions and 23 deletions Inline Diff

1 #ifndef __NET_IPIP_H 1 #ifndef __NET_IPIP_H
2 #define __NET_IPIP_H 1 2 #define __NET_IPIP_H 1
3 3
4 #include <linux/if_tunnel.h> 4 #include <linux/if_tunnel.h>
5 #include <net/ip.h> 5 #include <net/ip.h>
6 6
7 /* Keep error state on tunnel for 30 sec */ 7 /* Keep error state on tunnel for 30 sec */
8 #define IPTUNNEL_ERR_TIMEO (30*HZ) 8 #define IPTUNNEL_ERR_TIMEO (30*HZ)
9 9
10 /* 6rd prefix/relay information */ 10 /* 6rd prefix/relay information */
11 struct ip_tunnel_6rd_parm 11 struct ip_tunnel_6rd_parm
12 { 12 {
13 struct in6_addr prefix; 13 struct in6_addr prefix;
14 __be32 relay_prefix; 14 __be32 relay_prefix;
15 u16 prefixlen; 15 u16 prefixlen;
16 u16 relay_prefixlen; 16 u16 relay_prefixlen;
17 }; 17 };
18 18
19 struct ip_tunnel 19 struct ip_tunnel
20 { 20 {
21 struct ip_tunnel *next; 21 struct ip_tunnel *next;
22 struct net_device *dev; 22 struct net_device *dev;
23 23
24 int err_count; /* Number of arrived ICMP errors */ 24 int err_count; /* Number of arrived ICMP errors */
25 unsigned long err_time; /* Time when the last ICMP error arrived */ 25 unsigned long err_time; /* Time when the last ICMP error arrived */
26 26
27 /* These four fields used only by GRE */ 27 /* These four fields used only by GRE */
28 __u32 i_seqno; /* The last seen seqno */ 28 __u32 i_seqno; /* The last seen seqno */
29 __u32 o_seqno; /* The last output seqno */ 29 __u32 o_seqno; /* The last output seqno */
30 int hlen; /* Precalculated GRE header length */ 30 int hlen; /* Precalculated GRE header length */
31 int mlink; 31 int mlink;
32 32
33 struct ip_tunnel_parm parms; 33 struct ip_tunnel_parm parms;
34 34
35 /* for SIT */ 35 /* for SIT */
36 #ifdef CONFIG_IPV6_SIT_6RD 36 #ifdef CONFIG_IPV6_SIT_6RD
37 struct ip_tunnel_6rd_parm ip6rd; 37 struct ip_tunnel_6rd_parm ip6rd;
38 #endif 38 #endif
39 struct ip_tunnel_prl_entry *prl; /* potential router list */ 39 struct ip_tunnel_prl_entry *prl; /* potential router list */
40 unsigned int prl_count; /* # of entries in PRL */ 40 unsigned int prl_count; /* # of entries in PRL */
41 }; 41 };
42 42
43 struct ip_tunnel_prl_entry 43 struct ip_tunnel_prl_entry
44 { 44 {
45 struct ip_tunnel_prl_entry *next; 45 struct ip_tunnel_prl_entry *next;
46 __be32 addr; 46 __be32 addr;
47 u16 flags; 47 u16 flags;
48 struct rcu_head rcu_head;
48 }; 49 };
49 50
50 #define IPTUNNEL_XMIT() do { \ 51 #define IPTUNNEL_XMIT() do { \
51 int err; \ 52 int err; \
52 int pkt_len = skb->len - skb_transport_offset(skb); \ 53 int pkt_len = skb->len - skb_transport_offset(skb); \
53 \ 54 \
54 skb->ip_summed = CHECKSUM_NONE; \ 55 skb->ip_summed = CHECKSUM_NONE; \
55 ip_select_ident(iph, &rt->u.dst, NULL); \ 56 ip_select_ident(iph, &rt->u.dst, NULL); \
56 \ 57 \
57 err = ip_local_out(skb); \ 58 err = ip_local_out(skb); \
58 if (likely(net_xmit_eval(err) == 0)) { \ 59 if (likely(net_xmit_eval(err) == 0)) { \
59 txq->tx_bytes += pkt_len; \ 60 txq->tx_bytes += pkt_len; \
60 txq->tx_packets++; \ 61 txq->tx_packets++; \
61 } else { \ 62 } else { \
62 stats->tx_errors++; \ 63 stats->tx_errors++; \
63 stats->tx_aborted_errors++; \ 64 stats->tx_aborted_errors++; \
64 } \ 65 } \
65 } while (0) 66 } while (0)
66 67
67 #endif 68 #endif
68 69
1 /* 1 /*
2 * IPv6 over IPv4 tunnel device - Simple Internet Transition (SIT) 2 * IPv6 over IPv4 tunnel device - Simple Internet Transition (SIT)
3 * Linux INET6 implementation 3 * Linux INET6 implementation
4 * 4 *
5 * Authors: 5 * Authors:
6 * Pedro Roque <roque@di.fc.ul.pt> 6 * Pedro Roque <roque@di.fc.ul.pt>
7 * Alexey Kuznetsov <kuznet@ms2.inr.ac.ru> 7 * Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
8 * 8 *
9 * This program is free software; you can redistribute it and/or 9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License 10 * modify it under the terms of the GNU General Public License
11 * as published by the Free Software Foundation; either version 11 * as published by the Free Software Foundation; either version
12 * 2 of the License, or (at your option) any later version. 12 * 2 of the License, or (at your option) any later version.
13 * 13 *
14 * Changes: 14 * Changes:
15 * Roger Venning <r.venning@telstra.com>: 6to4 support 15 * Roger Venning <r.venning@telstra.com>: 6to4 support
16 * Nate Thompson <nate@thebog.net>: 6to4 support 16 * Nate Thompson <nate@thebog.net>: 6to4 support
17 * Fred Templin <fred.l.templin@boeing.com>: isatap support 17 * Fred Templin <fred.l.templin@boeing.com>: isatap support
18 */ 18 */
19 19
20 #include <linux/module.h> 20 #include <linux/module.h>
21 #include <linux/capability.h> 21 #include <linux/capability.h>
22 #include <linux/errno.h> 22 #include <linux/errno.h>
23 #include <linux/types.h> 23 #include <linux/types.h>
24 #include <linux/socket.h> 24 #include <linux/socket.h>
25 #include <linux/sockios.h> 25 #include <linux/sockios.h>
26 #include <linux/net.h> 26 #include <linux/net.h>
27 #include <linux/in6.h> 27 #include <linux/in6.h>
28 #include <linux/netdevice.h> 28 #include <linux/netdevice.h>
29 #include <linux/if_arp.h> 29 #include <linux/if_arp.h>
30 #include <linux/icmp.h> 30 #include <linux/icmp.h>
31 #include <asm/uaccess.h> 31 #include <asm/uaccess.h>
32 #include <linux/init.h> 32 #include <linux/init.h>
33 #include <linux/netfilter_ipv4.h> 33 #include <linux/netfilter_ipv4.h>
34 #include <linux/if_ether.h> 34 #include <linux/if_ether.h>
35 35
36 #include <net/sock.h> 36 #include <net/sock.h>
37 #include <net/snmp.h> 37 #include <net/snmp.h>
38 38
39 #include <net/ipv6.h> 39 #include <net/ipv6.h>
40 #include <net/protocol.h> 40 #include <net/protocol.h>
41 #include <net/transp_v6.h> 41 #include <net/transp_v6.h>
42 #include <net/ip6_fib.h> 42 #include <net/ip6_fib.h>
43 #include <net/ip6_route.h> 43 #include <net/ip6_route.h>
44 #include <net/ndisc.h> 44 #include <net/ndisc.h>
45 #include <net/addrconf.h> 45 #include <net/addrconf.h>
46 #include <net/ip.h> 46 #include <net/ip.h>
47 #include <net/udp.h> 47 #include <net/udp.h>
48 #include <net/icmp.h> 48 #include <net/icmp.h>
49 #include <net/ipip.h> 49 #include <net/ipip.h>
50 #include <net/inet_ecn.h> 50 #include <net/inet_ecn.h>
51 #include <net/xfrm.h> 51 #include <net/xfrm.h>
52 #include <net/dsfield.h> 52 #include <net/dsfield.h>
53 #include <net/net_namespace.h> 53 #include <net/net_namespace.h>
54 #include <net/netns/generic.h> 54 #include <net/netns/generic.h>
55 55
56 /* 56 /*
57 This version of net/ipv6/sit.c is cloned of net/ipv4/ip_gre.c 57 This version of net/ipv6/sit.c is cloned of net/ipv4/ip_gre.c
58 58
59 For comments look at net/ipv4/ip_gre.c --ANK 59 For comments look at net/ipv4/ip_gre.c --ANK
60 */ 60 */
61 61
62 #define HASH_SIZE 16 62 #define HASH_SIZE 16
63 #define HASH(addr) (((__force u32)addr^((__force u32)addr>>4))&0xF) 63 #define HASH(addr) (((__force u32)addr^((__force u32)addr>>4))&0xF)
64 64
65 static void ipip6_fb_tunnel_init(struct net_device *dev); 65 static void ipip6_fb_tunnel_init(struct net_device *dev);
66 static void ipip6_tunnel_init(struct net_device *dev); 66 static void ipip6_tunnel_init(struct net_device *dev);
67 static void ipip6_tunnel_setup(struct net_device *dev); 67 static void ipip6_tunnel_setup(struct net_device *dev);
68 68
69 static int sit_net_id; 69 static int sit_net_id;
70 struct sit_net { 70 struct sit_net {
71 struct ip_tunnel *tunnels_r_l[HASH_SIZE]; 71 struct ip_tunnel *tunnels_r_l[HASH_SIZE];
72 struct ip_tunnel *tunnels_r[HASH_SIZE]; 72 struct ip_tunnel *tunnels_r[HASH_SIZE];
73 struct ip_tunnel *tunnels_l[HASH_SIZE]; 73 struct ip_tunnel *tunnels_l[HASH_SIZE];
74 struct ip_tunnel *tunnels_wc[1]; 74 struct ip_tunnel *tunnels_wc[1];
75 struct ip_tunnel **tunnels[4]; 75 struct ip_tunnel **tunnels[4];
76 76
77 struct net_device *fb_tunnel_dev; 77 struct net_device *fb_tunnel_dev;
78 }; 78 };
79 79
80 static DEFINE_RWLOCK(ipip6_lock); 80 static DEFINE_RWLOCK(ipip6_lock);
81 81
82 static struct ip_tunnel * ipip6_tunnel_lookup(struct net *net, 82 static struct ip_tunnel * ipip6_tunnel_lookup(struct net *net,
83 struct net_device *dev, __be32 remote, __be32 local) 83 struct net_device *dev, __be32 remote, __be32 local)
84 { 84 {
85 unsigned h0 = HASH(remote); 85 unsigned h0 = HASH(remote);
86 unsigned h1 = HASH(local); 86 unsigned h1 = HASH(local);
87 struct ip_tunnel *t; 87 struct ip_tunnel *t;
88 struct sit_net *sitn = net_generic(net, sit_net_id); 88 struct sit_net *sitn = net_generic(net, sit_net_id);
89 89
90 for (t = sitn->tunnels_r_l[h0^h1]; t; t = t->next) { 90 for (t = sitn->tunnels_r_l[h0^h1]; t; t = t->next) {
91 if (local == t->parms.iph.saddr && 91 if (local == t->parms.iph.saddr &&
92 remote == t->parms.iph.daddr && 92 remote == t->parms.iph.daddr &&
93 (!dev || !t->parms.link || dev->iflink == t->parms.link) && 93 (!dev || !t->parms.link || dev->iflink == t->parms.link) &&
94 (t->dev->flags & IFF_UP)) 94 (t->dev->flags & IFF_UP))
95 return t; 95 return t;
96 } 96 }
97 for (t = sitn->tunnels_r[h0]; t; t = t->next) { 97 for (t = sitn->tunnels_r[h0]; t; t = t->next) {
98 if (remote == t->parms.iph.daddr && 98 if (remote == t->parms.iph.daddr &&
99 (!dev || !t->parms.link || dev->iflink == t->parms.link) && 99 (!dev || !t->parms.link || dev->iflink == t->parms.link) &&
100 (t->dev->flags & IFF_UP)) 100 (t->dev->flags & IFF_UP))
101 return t; 101 return t;
102 } 102 }
103 for (t = sitn->tunnels_l[h1]; t; t = t->next) { 103 for (t = sitn->tunnels_l[h1]; t; t = t->next) {
104 if (local == t->parms.iph.saddr && 104 if (local == t->parms.iph.saddr &&
105 (!dev || !t->parms.link || dev->iflink == t->parms.link) && 105 (!dev || !t->parms.link || dev->iflink == t->parms.link) &&
106 (t->dev->flags & IFF_UP)) 106 (t->dev->flags & IFF_UP))
107 return t; 107 return t;
108 } 108 }
109 t = sitn->tunnels_wc[0]; 109 t = sitn->tunnels_wc[0];
110 if ((t != NULL) && (t->dev->flags & IFF_UP)) 110 if ((t != NULL) && (t->dev->flags & IFF_UP))
111 return t; 111 return t;
112 return NULL; 112 return NULL;
113 } 113 }
114 114
115 static struct ip_tunnel **__ipip6_bucket(struct sit_net *sitn, 115 static struct ip_tunnel **__ipip6_bucket(struct sit_net *sitn,
116 struct ip_tunnel_parm *parms) 116 struct ip_tunnel_parm *parms)
117 { 117 {
118 __be32 remote = parms->iph.daddr; 118 __be32 remote = parms->iph.daddr;
119 __be32 local = parms->iph.saddr; 119 __be32 local = parms->iph.saddr;
120 unsigned h = 0; 120 unsigned h = 0;
121 int prio = 0; 121 int prio = 0;
122 122
123 if (remote) { 123 if (remote) {
124 prio |= 2; 124 prio |= 2;
125 h ^= HASH(remote); 125 h ^= HASH(remote);
126 } 126 }
127 if (local) { 127 if (local) {
128 prio |= 1; 128 prio |= 1;
129 h ^= HASH(local); 129 h ^= HASH(local);
130 } 130 }
131 return &sitn->tunnels[prio][h]; 131 return &sitn->tunnels[prio][h];
132 } 132 }
133 133
134 static inline struct ip_tunnel **ipip6_bucket(struct sit_net *sitn, 134 static inline struct ip_tunnel **ipip6_bucket(struct sit_net *sitn,
135 struct ip_tunnel *t) 135 struct ip_tunnel *t)
136 { 136 {
137 return __ipip6_bucket(sitn, &t->parms); 137 return __ipip6_bucket(sitn, &t->parms);
138 } 138 }
139 139
140 static void ipip6_tunnel_unlink(struct sit_net *sitn, struct ip_tunnel *t) 140 static void ipip6_tunnel_unlink(struct sit_net *sitn, struct ip_tunnel *t)
141 { 141 {
142 struct ip_tunnel **tp; 142 struct ip_tunnel **tp;
143 143
144 for (tp = ipip6_bucket(sitn, t); *tp; tp = &(*tp)->next) { 144 for (tp = ipip6_bucket(sitn, t); *tp; tp = &(*tp)->next) {
145 if (t == *tp) { 145 if (t == *tp) {
146 write_lock_bh(&ipip6_lock); 146 write_lock_bh(&ipip6_lock);
147 *tp = t->next; 147 *tp = t->next;
148 write_unlock_bh(&ipip6_lock); 148 write_unlock_bh(&ipip6_lock);
149 break; 149 break;
150 } 150 }
151 } 151 }
152 } 152 }
153 153
154 static void ipip6_tunnel_link(struct sit_net *sitn, struct ip_tunnel *t) 154 static void ipip6_tunnel_link(struct sit_net *sitn, struct ip_tunnel *t)
155 { 155 {
156 struct ip_tunnel **tp = ipip6_bucket(sitn, t); 156 struct ip_tunnel **tp = ipip6_bucket(sitn, t);
157 157
158 t->next = *tp; 158 t->next = *tp;
159 write_lock_bh(&ipip6_lock); 159 write_lock_bh(&ipip6_lock);
160 *tp = t; 160 *tp = t;
161 write_unlock_bh(&ipip6_lock); 161 write_unlock_bh(&ipip6_lock);
162 } 162 }
163 163
164 static void ipip6_tunnel_clone_6rd(struct net_device *dev, struct sit_net *sitn) 164 static void ipip6_tunnel_clone_6rd(struct net_device *dev, struct sit_net *sitn)
165 { 165 {
166 #ifdef CONFIG_IPV6_SIT_6RD 166 #ifdef CONFIG_IPV6_SIT_6RD
167 struct ip_tunnel *t = netdev_priv(dev); 167 struct ip_tunnel *t = netdev_priv(dev);
168 168
169 if (t->dev == sitn->fb_tunnel_dev) { 169 if (t->dev == sitn->fb_tunnel_dev) {
170 ipv6_addr_set(&t->ip6rd.prefix, htonl(0x20020000), 0, 0, 0); 170 ipv6_addr_set(&t->ip6rd.prefix, htonl(0x20020000), 0, 0, 0);
171 t->ip6rd.relay_prefix = 0; 171 t->ip6rd.relay_prefix = 0;
172 t->ip6rd.prefixlen = 16; 172 t->ip6rd.prefixlen = 16;
173 t->ip6rd.relay_prefixlen = 0; 173 t->ip6rd.relay_prefixlen = 0;
174 } else { 174 } else {
175 struct ip_tunnel *t0 = netdev_priv(sitn->fb_tunnel_dev); 175 struct ip_tunnel *t0 = netdev_priv(sitn->fb_tunnel_dev);
176 memcpy(&t->ip6rd, &t0->ip6rd, sizeof(t->ip6rd)); 176 memcpy(&t->ip6rd, &t0->ip6rd, sizeof(t->ip6rd));
177 } 177 }
178 #endif 178 #endif
179 } 179 }
180 180
181 static struct ip_tunnel * ipip6_tunnel_locate(struct net *net, 181 static struct ip_tunnel * ipip6_tunnel_locate(struct net *net,
182 struct ip_tunnel_parm *parms, int create) 182 struct ip_tunnel_parm *parms, int create)
183 { 183 {
184 __be32 remote = parms->iph.daddr; 184 __be32 remote = parms->iph.daddr;
185 __be32 local = parms->iph.saddr; 185 __be32 local = parms->iph.saddr;
186 struct ip_tunnel *t, **tp, *nt; 186 struct ip_tunnel *t, **tp, *nt;
187 struct net_device *dev; 187 struct net_device *dev;
188 char name[IFNAMSIZ]; 188 char name[IFNAMSIZ];
189 struct sit_net *sitn = net_generic(net, sit_net_id); 189 struct sit_net *sitn = net_generic(net, sit_net_id);
190 190
191 for (tp = __ipip6_bucket(sitn, parms); (t = *tp) != NULL; tp = &t->next) { 191 for (tp = __ipip6_bucket(sitn, parms); (t = *tp) != NULL; tp = &t->next) {
192 if (local == t->parms.iph.saddr && 192 if (local == t->parms.iph.saddr &&
193 remote == t->parms.iph.daddr && 193 remote == t->parms.iph.daddr &&
194 parms->link == t->parms.link) { 194 parms->link == t->parms.link) {
195 if (create) 195 if (create)
196 return NULL; 196 return NULL;
197 else 197 else
198 return t; 198 return t;
199 } 199 }
200 } 200 }
201 if (!create) 201 if (!create)
202 goto failed; 202 goto failed;
203 203
204 if (parms->name[0]) 204 if (parms->name[0])
205 strlcpy(name, parms->name, IFNAMSIZ); 205 strlcpy(name, parms->name, IFNAMSIZ);
206 else 206 else
207 sprintf(name, "sit%%d"); 207 sprintf(name, "sit%%d");
208 208
209 dev = alloc_netdev(sizeof(*t), name, ipip6_tunnel_setup); 209 dev = alloc_netdev(sizeof(*t), name, ipip6_tunnel_setup);
210 if (dev == NULL) 210 if (dev == NULL)
211 return NULL; 211 return NULL;
212 212
213 dev_net_set(dev, net); 213 dev_net_set(dev, net);
214 214
215 if (strchr(name, '%')) { 215 if (strchr(name, '%')) {
216 if (dev_alloc_name(dev, name) < 0) 216 if (dev_alloc_name(dev, name) < 0)
217 goto failed_free; 217 goto failed_free;
218 } 218 }
219 219
220 nt = netdev_priv(dev); 220 nt = netdev_priv(dev);
221 221
222 nt->parms = *parms; 222 nt->parms = *parms;
223 ipip6_tunnel_init(dev); 223 ipip6_tunnel_init(dev);
224 ipip6_tunnel_clone_6rd(dev, sitn); 224 ipip6_tunnel_clone_6rd(dev, sitn);
225 225
226 if (parms->i_flags & SIT_ISATAP) 226 if (parms->i_flags & SIT_ISATAP)
227 dev->priv_flags |= IFF_ISATAP; 227 dev->priv_flags |= IFF_ISATAP;
228 228
229 if (register_netdevice(dev) < 0) 229 if (register_netdevice(dev) < 0)
230 goto failed_free; 230 goto failed_free;
231 231
232 dev_hold(dev); 232 dev_hold(dev);
233 233
234 ipip6_tunnel_link(sitn, nt); 234 ipip6_tunnel_link(sitn, nt);
235 return nt; 235 return nt;
236 236
237 failed_free: 237 failed_free:
238 free_netdev(dev); 238 free_netdev(dev);
239 failed: 239 failed:
240 return NULL; 240 return NULL;
241 } 241 }
242 242
243 static DEFINE_SPINLOCK(ipip6_prl_lock);
244
245 #define for_each_prl_rcu(start) \
246 for (prl = rcu_dereference(start); \
247 prl; \
248 prl = rcu_dereference(prl->next))
249
243 static struct ip_tunnel_prl_entry * 250 static struct ip_tunnel_prl_entry *
244 __ipip6_tunnel_locate_prl(struct ip_tunnel *t, __be32 addr) 251 __ipip6_tunnel_locate_prl(struct ip_tunnel *t, __be32 addr)
245 { 252 {
246 struct ip_tunnel_prl_entry *p = (struct ip_tunnel_prl_entry *)NULL; 253 struct ip_tunnel_prl_entry *prl;
247 254
248 for (p = t->prl; p; p = p->next) 255 for_each_prl_rcu(t->prl)
249 if (p->addr == addr) 256 if (prl->addr == addr)
250 break; 257 break;
251 return p; 258 return prl;
252 259
253 } 260 }
254 261
255 static int ipip6_tunnel_get_prl(struct ip_tunnel *t, 262 static int ipip6_tunnel_get_prl(struct ip_tunnel *t,
256 struct ip_tunnel_prl __user *a) 263 struct ip_tunnel_prl __user *a)
257 { 264 {
258 struct ip_tunnel_prl kprl, *kp; 265 struct ip_tunnel_prl kprl, *kp;
259 struct ip_tunnel_prl_entry *prl; 266 struct ip_tunnel_prl_entry *prl;
260 unsigned int cmax, c = 0, ca, len; 267 unsigned int cmax, c = 0, ca, len;
261 int ret = 0; 268 int ret = 0;
262 269
263 if (copy_from_user(&kprl, a, sizeof(kprl))) 270 if (copy_from_user(&kprl, a, sizeof(kprl)))
264 return -EFAULT; 271 return -EFAULT;
265 cmax = kprl.datalen / sizeof(kprl); 272 cmax = kprl.datalen / sizeof(kprl);
266 if (cmax > 1 && kprl.addr != htonl(INADDR_ANY)) 273 if (cmax > 1 && kprl.addr != htonl(INADDR_ANY))
267 cmax = 1; 274 cmax = 1;
268 275
269 /* For simple GET or for root users, 276 /* For simple GET or for root users,
270 * we try harder to allocate. 277 * we try harder to allocate.
271 */ 278 */
272 kp = (cmax <= 1 || capable(CAP_NET_ADMIN)) ? 279 kp = (cmax <= 1 || capable(CAP_NET_ADMIN)) ?
273 kcalloc(cmax, sizeof(*kp), GFP_KERNEL) : 280 kcalloc(cmax, sizeof(*kp), GFP_KERNEL) :
274 NULL; 281 NULL;
275 282
276 read_lock(&ipip6_lock); 283 rcu_read_lock();
277 284
278 ca = t->prl_count < cmax ? t->prl_count : cmax; 285 ca = t->prl_count < cmax ? t->prl_count : cmax;
279 286
280 if (!kp) { 287 if (!kp) {
281 /* We don't try hard to allocate much memory for 288 /* We don't try hard to allocate much memory for
282 * non-root users. 289 * non-root users.
283 * For root users, retry allocating enough memory for 290 * For root users, retry allocating enough memory for
284 * the answer. 291 * the answer.
285 */ 292 */
286 kp = kcalloc(ca, sizeof(*kp), GFP_ATOMIC); 293 kp = kcalloc(ca, sizeof(*kp), GFP_ATOMIC);
287 if (!kp) { 294 if (!kp) {
288 ret = -ENOMEM; 295 ret = -ENOMEM;
289 goto out; 296 goto out;
290 } 297 }
291 } 298 }
292 299
293 c = 0; 300 c = 0;
294 for (prl = t->prl; prl; prl = prl->next) { 301 for_each_prl_rcu(t->prl) {
295 if (c >= cmax) 302 if (c >= cmax)
296 break; 303 break;
297 if (kprl.addr != htonl(INADDR_ANY) && prl->addr != kprl.addr) 304 if (kprl.addr != htonl(INADDR_ANY) && prl->addr != kprl.addr)
298 continue; 305 continue;
299 kp[c].addr = prl->addr; 306 kp[c].addr = prl->addr;
300 kp[c].flags = prl->flags; 307 kp[c].flags = prl->flags;
301 c++; 308 c++;
302 if (kprl.addr != htonl(INADDR_ANY)) 309 if (kprl.addr != htonl(INADDR_ANY))
303 break; 310 break;
304 } 311 }
305 out: 312 out:
306 read_unlock(&ipip6_lock); 313 rcu_read_unlock();
307 314
308 len = sizeof(*kp) * c; 315 len = sizeof(*kp) * c;
309 ret = 0; 316 ret = 0;
310 if ((len && copy_to_user(a + 1, kp, len)) || put_user(len, &a->datalen)) 317 if ((len && copy_to_user(a + 1, kp, len)) || put_user(len, &a->datalen))
311 ret = -EFAULT; 318 ret = -EFAULT;
312 319
313 kfree(kp); 320 kfree(kp);
314 321
315 return ret; 322 return ret;
316 } 323 }
317 324
318 static int 325 static int
319 ipip6_tunnel_add_prl(struct ip_tunnel *t, struct ip_tunnel_prl *a, int chg) 326 ipip6_tunnel_add_prl(struct ip_tunnel *t, struct ip_tunnel_prl *a, int chg)
320 { 327 {
321 struct ip_tunnel_prl_entry *p; 328 struct ip_tunnel_prl_entry *p;
322 int err = 0; 329 int err = 0;
323 330
324 if (a->addr == htonl(INADDR_ANY)) 331 if (a->addr == htonl(INADDR_ANY))
325 return -EINVAL; 332 return -EINVAL;
326 333
327 write_lock(&ipip6_lock); 334 spin_lock(&ipip6_prl_lock);
328 335
329 for (p = t->prl; p; p = p->next) { 336 for (p = t->prl; p; p = p->next) {
330 if (p->addr == a->addr) { 337 if (p->addr == a->addr) {
331 if (chg) 338 if (chg) {
332 goto update; 339 p->flags = a->flags;
340 goto out;
341 }
333 err = -EEXIST; 342 err = -EEXIST;
334 goto out; 343 goto out;
335 } 344 }
336 } 345 }
337 346
338 if (chg) { 347 if (chg) {
339 err = -ENXIO; 348 err = -ENXIO;
340 goto out; 349 goto out;
341 } 350 }
342 351
343 p = kzalloc(sizeof(struct ip_tunnel_prl_entry), GFP_KERNEL); 352 p = kzalloc(sizeof(struct ip_tunnel_prl_entry), GFP_KERNEL);
344 if (!p) { 353 if (!p) {
345 err = -ENOBUFS; 354 err = -ENOBUFS;
346 goto out; 355 goto out;
347 } 356 }
348 357
358 INIT_RCU_HEAD(&p->rcu_head);
349 p->next = t->prl; 359 p->next = t->prl;
350 t->prl = p;
351 t->prl_count++;
352 update:
353 p->addr = a->addr; 360 p->addr = a->addr;
354 p->flags = a->flags; 361 p->flags = a->flags;
362 t->prl_count++;
363 rcu_assign_pointer(t->prl, p);
355 out: 364 out:
356 write_unlock(&ipip6_lock); 365 spin_unlock(&ipip6_prl_lock);
357 return err; 366 return err;
358 } 367 }
359 368
369 static void prl_entry_destroy_rcu(struct rcu_head *head)
370 {
371 kfree(container_of(head, struct ip_tunnel_prl_entry, rcu_head));
372 }
373
374 static void prl_list_destroy_rcu(struct rcu_head *head)
375 {
376 struct ip_tunnel_prl_entry *p, *n;
377
378 p = container_of(head, struct ip_tunnel_prl_entry, rcu_head);
379 do {
380 n = p->next;
381 kfree(p);
382 p = n;
383 } while (p);
384 }
385
360 static int 386 static int
361 ipip6_tunnel_del_prl(struct ip_tunnel *t, struct ip_tunnel_prl *a) 387 ipip6_tunnel_del_prl(struct ip_tunnel *t, struct ip_tunnel_prl *a)
362 { 388 {
363 struct ip_tunnel_prl_entry *x, **p; 389 struct ip_tunnel_prl_entry *x, **p;
364 int err = 0; 390 int err = 0;
365 391
366 write_lock(&ipip6_lock); 392 spin_lock(&ipip6_prl_lock);
367 393
368 if (a && a->addr != htonl(INADDR_ANY)) { 394 if (a && a->addr != htonl(INADDR_ANY)) {
369 for (p = &t->prl; *p; p = &(*p)->next) { 395 for (p = &t->prl; *p; p = &(*p)->next) {
370 if ((*p)->addr == a->addr) { 396 if ((*p)->addr == a->addr) {
371 x = *p; 397 x = *p;
372 *p = x->next; 398 *p = x->next;
373 kfree(x); 399 call_rcu(&x->rcu_head, prl_entry_destroy_rcu);
374 t->prl_count--; 400 t->prl_count--;
375 goto out; 401 goto out;
376 } 402 }
377 } 403 }
378 err = -ENXIO; 404 err = -ENXIO;
379 } else { 405 } else {
380 while (t->prl) { 406 if (t->prl) {
407 t->prl_count = 0;
381 x = t->prl; 408 x = t->prl;
382 t->prl = t->prl->next; 409 call_rcu(&x->rcu_head, prl_list_destroy_rcu);
383 kfree(x); 410 t->prl = NULL;
384 t->prl_count--;
385 } 411 }
386 } 412 }
387 out: 413 out:
388 write_unlock(&ipip6_lock); 414 spin_unlock(&ipip6_prl_lock);
389 return err; 415 return err;
390 } 416 }
391 417
392 static int 418 static int
393 isatap_chksrc(struct sk_buff *skb, struct iphdr *iph, struct ip_tunnel *t) 419 isatap_chksrc(struct sk_buff *skb, struct iphdr *iph, struct ip_tunnel *t)
394 { 420 {
395 struct ip_tunnel_prl_entry *p; 421 struct ip_tunnel_prl_entry *p;
396 int ok = 1; 422 int ok = 1;
397 423
398 read_lock(&ipip6_lock); 424 rcu_read_lock();
399 p = __ipip6_tunnel_locate_prl(t, iph->saddr); 425 p = __ipip6_tunnel_locate_prl(t, iph->saddr);
400 if (p) { 426 if (p) {
401 if (p->flags & PRL_DEFAULT) 427 if (p->flags & PRL_DEFAULT)
402 skb->ndisc_nodetype = NDISC_NODETYPE_DEFAULT; 428 skb->ndisc_nodetype = NDISC_NODETYPE_DEFAULT;
403 else 429 else
404 skb->ndisc_nodetype = NDISC_NODETYPE_NODEFAULT; 430 skb->ndisc_nodetype = NDISC_NODETYPE_NODEFAULT;
405 } else { 431 } else {
406 struct in6_addr *addr6 = &ipv6_hdr(skb)->saddr; 432 struct in6_addr *addr6 = &ipv6_hdr(skb)->saddr;
407 if (ipv6_addr_is_isatap(addr6) && 433 if (ipv6_addr_is_isatap(addr6) &&
408 (addr6->s6_addr32[3] == iph->saddr) && 434 (addr6->s6_addr32[3] == iph->saddr) &&
409 ipv6_chk_prefix(addr6, t->dev)) 435 ipv6_chk_prefix(addr6, t->dev))
410 skb->ndisc_nodetype = NDISC_NODETYPE_HOST; 436 skb->ndisc_nodetype = NDISC_NODETYPE_HOST;
411 else 437 else
412 ok = 0; 438 ok = 0;
413 } 439 }
414 read_unlock(&ipip6_lock); 440 rcu_read_unlock();
415 return ok; 441 return ok;
416 } 442 }
417 443
418 static void ipip6_tunnel_uninit(struct net_device *dev) 444 static void ipip6_tunnel_uninit(struct net_device *dev)
419 { 445 {
420 struct net *net = dev_net(dev); 446 struct net *net = dev_net(dev);
421 struct sit_net *sitn = net_generic(net, sit_net_id); 447 struct sit_net *sitn = net_generic(net, sit_net_id);
422 448
423 if (dev == sitn->fb_tunnel_dev) { 449 if (dev == sitn->fb_tunnel_dev) {
424 write_lock_bh(&ipip6_lock); 450 write_lock_bh(&ipip6_lock);
425 sitn->tunnels_wc[0] = NULL; 451 sitn->tunnels_wc[0] = NULL;
426 write_unlock_bh(&ipip6_lock); 452 write_unlock_bh(&ipip6_lock);
427 dev_put(dev); 453 dev_put(dev);
428 } else { 454 } else {
429 ipip6_tunnel_unlink(sitn, netdev_priv(dev)); 455 ipip6_tunnel_unlink(sitn, netdev_priv(dev));
430 ipip6_tunnel_del_prl(netdev_priv(dev), NULL); 456 ipip6_tunnel_del_prl(netdev_priv(dev), NULL);
431 dev_put(dev); 457 dev_put(dev);
432 } 458 }
433 } 459 }
434 460
435 461
436 static int ipip6_err(struct sk_buff *skb, u32 info) 462 static int ipip6_err(struct sk_buff *skb, u32 info)
437 { 463 {
438 464
439 /* All the routers (except for Linux) return only 465 /* All the routers (except for Linux) return only
440 8 bytes of packet payload. It means, that precise relaying of 466 8 bytes of packet payload. It means, that precise relaying of
441 ICMP in the real Internet is absolutely infeasible. 467 ICMP in the real Internet is absolutely infeasible.
442 */ 468 */
443 struct iphdr *iph = (struct iphdr*)skb->data; 469 struct iphdr *iph = (struct iphdr*)skb->data;
444 const int type = icmp_hdr(skb)->type; 470 const int type = icmp_hdr(skb)->type;
445 const int code = icmp_hdr(skb)->code; 471 const int code = icmp_hdr(skb)->code;
446 struct ip_tunnel *t; 472 struct ip_tunnel *t;
447 int err; 473 int err;
448 474
449 switch (type) { 475 switch (type) {
450 default: 476 default:
451 case ICMP_PARAMETERPROB: 477 case ICMP_PARAMETERPROB:
452 return 0; 478 return 0;
453 479
454 case ICMP_DEST_UNREACH: 480 case ICMP_DEST_UNREACH:
455 switch (code) { 481 switch (code) {
456 case ICMP_SR_FAILED: 482 case ICMP_SR_FAILED:
457 case ICMP_PORT_UNREACH: 483 case ICMP_PORT_UNREACH:
458 /* Impossible event. */ 484 /* Impossible event. */
459 return 0; 485 return 0;
460 case ICMP_FRAG_NEEDED: 486 case ICMP_FRAG_NEEDED:
461 /* Soft state for pmtu is maintained by IP core. */ 487 /* Soft state for pmtu is maintained by IP core. */
462 return 0; 488 return 0;
463 default: 489 default:
464 /* All others are translated to HOST_UNREACH. 490 /* All others are translated to HOST_UNREACH.
465 rfc2003 contains "deep thoughts" about NET_UNREACH, 491 rfc2003 contains "deep thoughts" about NET_UNREACH,
466 I believe they are just ether pollution. --ANK 492 I believe they are just ether pollution. --ANK
467 */ 493 */
468 break; 494 break;
469 } 495 }
470 break; 496 break;
471 case ICMP_TIME_EXCEEDED: 497 case ICMP_TIME_EXCEEDED:
472 if (code != ICMP_EXC_TTL) 498 if (code != ICMP_EXC_TTL)
473 return 0; 499 return 0;
474 break; 500 break;
475 } 501 }
476 502
477 err = -ENOENT; 503 err = -ENOENT;
478 504
479 read_lock(&ipip6_lock); 505 read_lock(&ipip6_lock);
480 t = ipip6_tunnel_lookup(dev_net(skb->dev), 506 t = ipip6_tunnel_lookup(dev_net(skb->dev),
481 skb->dev, 507 skb->dev,
482 iph->daddr, 508 iph->daddr,
483 iph->saddr); 509 iph->saddr);
484 if (t == NULL || t->parms.iph.daddr == 0) 510 if (t == NULL || t->parms.iph.daddr == 0)
485 goto out; 511 goto out;
486 512
487 err = 0; 513 err = 0;
488 if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED) 514 if (t->parms.iph.ttl == 0 && type == ICMP_TIME_EXCEEDED)
489 goto out; 515 goto out;
490 516
491 if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO)) 517 if (time_before(jiffies, t->err_time + IPTUNNEL_ERR_TIMEO))
492 t->err_count++; 518 t->err_count++;
493 else 519 else
494 t->err_count = 1; 520 t->err_count = 1;
495 t->err_time = jiffies; 521 t->err_time = jiffies;
496 out: 522 out:
497 read_unlock(&ipip6_lock); 523 read_unlock(&ipip6_lock);
498 return err; 524 return err;
499 } 525 }
500 526
501 static inline void ipip6_ecn_decapsulate(struct iphdr *iph, struct sk_buff *skb) 527 static inline void ipip6_ecn_decapsulate(struct iphdr *iph, struct sk_buff *skb)
502 { 528 {
503 if (INET_ECN_is_ce(iph->tos)) 529 if (INET_ECN_is_ce(iph->tos))
504 IP6_ECN_set_ce(ipv6_hdr(skb)); 530 IP6_ECN_set_ce(ipv6_hdr(skb));
505 } 531 }
506 532
507 static int ipip6_rcv(struct sk_buff *skb) 533 static int ipip6_rcv(struct sk_buff *skb)
508 { 534 {
509 struct iphdr *iph; 535 struct iphdr *iph;
510 struct ip_tunnel *tunnel; 536 struct ip_tunnel *tunnel;
511 537
512 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr))) 538 if (!pskb_may_pull(skb, sizeof(struct ipv6hdr)))
513 goto out; 539 goto out;
514 540
515 iph = ip_hdr(skb); 541 iph = ip_hdr(skb);
516 542
517 read_lock(&ipip6_lock); 543 read_lock(&ipip6_lock);
518 tunnel = ipip6_tunnel_lookup(dev_net(skb->dev), skb->dev, 544 tunnel = ipip6_tunnel_lookup(dev_net(skb->dev), skb->dev,
519 iph->saddr, iph->daddr); 545 iph->saddr, iph->daddr);
520 if (tunnel != NULL) { 546 if (tunnel != NULL) {
521 secpath_reset(skb); 547 secpath_reset(skb);
522 skb->mac_header = skb->network_header; 548 skb->mac_header = skb->network_header;
523 skb_reset_network_header(skb); 549 skb_reset_network_header(skb);
524 IPCB(skb)->flags = 0; 550 IPCB(skb)->flags = 0;
525 skb->protocol = htons(ETH_P_IPV6); 551 skb->protocol = htons(ETH_P_IPV6);
526 skb->pkt_type = PACKET_HOST; 552 skb->pkt_type = PACKET_HOST;
527 553
528 if ((tunnel->dev->priv_flags & IFF_ISATAP) && 554 if ((tunnel->dev->priv_flags & IFF_ISATAP) &&
529 !isatap_chksrc(skb, iph, tunnel)) { 555 !isatap_chksrc(skb, iph, tunnel)) {
530 tunnel->dev->stats.rx_errors++; 556 tunnel->dev->stats.rx_errors++;
531 read_unlock(&ipip6_lock); 557 read_unlock(&ipip6_lock);
532 kfree_skb(skb); 558 kfree_skb(skb);
533 return 0; 559 return 0;
534 } 560 }
535 tunnel->dev->stats.rx_packets++; 561 tunnel->dev->stats.rx_packets++;
536 tunnel->dev->stats.rx_bytes += skb->len; 562 tunnel->dev->stats.rx_bytes += skb->len;
537 skb->dev = tunnel->dev; 563 skb->dev = tunnel->dev;
538 skb_dst_drop(skb); 564 skb_dst_drop(skb);
539 nf_reset(skb); 565 nf_reset(skb);
540 ipip6_ecn_decapsulate(iph, skb); 566 ipip6_ecn_decapsulate(iph, skb);
541 netif_rx(skb); 567 netif_rx(skb);
542 read_unlock(&ipip6_lock); 568 read_unlock(&ipip6_lock);
543 return 0; 569 return 0;
544 } 570 }
545 571
546 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0); 572 icmp_send(skb, ICMP_DEST_UNREACH, ICMP_PORT_UNREACH, 0);
547 read_unlock(&ipip6_lock); 573 read_unlock(&ipip6_lock);
548 out: 574 out:
549 kfree_skb(skb); 575 kfree_skb(skb);
550 return 0; 576 return 0;
551 } 577 }
552 578
553 /* 579 /*
554 * Returns the embedded IPv4 address if the IPv6 address 580 * Returns the embedded IPv4 address if the IPv6 address
555 * comes from 6rd / 6to4 (RFC 3056) addr space. 581 * comes from 6rd / 6to4 (RFC 3056) addr space.
556 */ 582 */
557 static inline 583 static inline
558 __be32 try_6rd(struct in6_addr *v6dst, struct ip_tunnel *tunnel) 584 __be32 try_6rd(struct in6_addr *v6dst, struct ip_tunnel *tunnel)
559 { 585 {
560 __be32 dst = 0; 586 __be32 dst = 0;
561 587
562 #ifdef CONFIG_IPV6_SIT_6RD 588 #ifdef CONFIG_IPV6_SIT_6RD
563 if (ipv6_prefix_equal(v6dst, &tunnel->ip6rd.prefix, 589 if (ipv6_prefix_equal(v6dst, &tunnel->ip6rd.prefix,
564 tunnel->ip6rd.prefixlen)) { 590 tunnel->ip6rd.prefixlen)) {
565 unsigned pbw0, pbi0; 591 unsigned pbw0, pbi0;
566 int pbi1; 592 int pbi1;
567 u32 d; 593 u32 d;
568 594
569 pbw0 = tunnel->ip6rd.prefixlen >> 5; 595 pbw0 = tunnel->ip6rd.prefixlen >> 5;
570 pbi0 = tunnel->ip6rd.prefixlen & 0x1f; 596 pbi0 = tunnel->ip6rd.prefixlen & 0x1f;
571 597
572 d = (ntohl(v6dst->s6_addr32[pbw0]) << pbi0) >> 598 d = (ntohl(v6dst->s6_addr32[pbw0]) << pbi0) >>
573 tunnel->ip6rd.relay_prefixlen; 599 tunnel->ip6rd.relay_prefixlen;
574 600
575 pbi1 = pbi0 - tunnel->ip6rd.relay_prefixlen; 601 pbi1 = pbi0 - tunnel->ip6rd.relay_prefixlen;
576 if (pbi1 > 0) 602 if (pbi1 > 0)
577 d |= ntohl(v6dst->s6_addr32[pbw0 + 1]) >> 603 d |= ntohl(v6dst->s6_addr32[pbw0 + 1]) >>
578 (32 - pbi1); 604 (32 - pbi1);
579 605
580 dst = tunnel->ip6rd.relay_prefix | htonl(d); 606 dst = tunnel->ip6rd.relay_prefix | htonl(d);
581 } 607 }
582 #else 608 #else
583 if (v6dst->s6_addr16[0] == htons(0x2002)) { 609 if (v6dst->s6_addr16[0] == htons(0x2002)) {
584 /* 6to4 v6 addr has 16 bits prefix, 32 v4addr, 16 SLA, ... */ 610 /* 6to4 v6 addr has 16 bits prefix, 32 v4addr, 16 SLA, ... */
585 memcpy(&dst, &v6dst->s6_addr16[1], 4); 611 memcpy(&dst, &v6dst->s6_addr16[1], 4);
586 } 612 }
587 #endif 613 #endif
588 return dst; 614 return dst;
589 } 615 }
590 616
591 /* 617 /*
592 * This function assumes it is being called from dev_queue_xmit() 618 * This function assumes it is being called from dev_queue_xmit()
593 * and that skb is filled properly by that function. 619 * and that skb is filled properly by that function.
594 */ 620 */
595 621
596 static netdev_tx_t ipip6_tunnel_xmit(struct sk_buff *skb, 622 static netdev_tx_t ipip6_tunnel_xmit(struct sk_buff *skb,
597 struct net_device *dev) 623 struct net_device *dev)
598 { 624 {
599 struct ip_tunnel *tunnel = netdev_priv(dev); 625 struct ip_tunnel *tunnel = netdev_priv(dev);
600 struct net_device_stats *stats = &dev->stats; 626 struct net_device_stats *stats = &dev->stats;
601 struct netdev_queue *txq = netdev_get_tx_queue(dev, 0); 627 struct netdev_queue *txq = netdev_get_tx_queue(dev, 0);
602 struct iphdr *tiph = &tunnel->parms.iph; 628 struct iphdr *tiph = &tunnel->parms.iph;
603 struct ipv6hdr *iph6 = ipv6_hdr(skb); 629 struct ipv6hdr *iph6 = ipv6_hdr(skb);
604 u8 tos = tunnel->parms.iph.tos; 630 u8 tos = tunnel->parms.iph.tos;
605 struct rtable *rt; /* Route to the other host */ 631 struct rtable *rt; /* Route to the other host */
606 struct net_device *tdev; /* Device to other host */ 632 struct net_device *tdev; /* Device to other host */
607 struct iphdr *iph; /* Our new IP header */ 633 struct iphdr *iph; /* Our new IP header */
608 unsigned int max_headroom; /* The extra header space needed */ 634 unsigned int max_headroom; /* The extra header space needed */
609 __be32 dst = tiph->daddr; 635 __be32 dst = tiph->daddr;
610 int mtu; 636 int mtu;
611 struct in6_addr *addr6; 637 struct in6_addr *addr6;
612 int addr_type; 638 int addr_type;
613 639
614 if (skb->protocol != htons(ETH_P_IPV6)) 640 if (skb->protocol != htons(ETH_P_IPV6))
615 goto tx_error; 641 goto tx_error;
616 642
617 /* ISATAP (RFC4214) - must come before 6to4 */ 643 /* ISATAP (RFC4214) - must come before 6to4 */
618 if (dev->priv_flags & IFF_ISATAP) { 644 if (dev->priv_flags & IFF_ISATAP) {
619 struct neighbour *neigh = NULL; 645 struct neighbour *neigh = NULL;
620 646
621 if (skb_dst(skb)) 647 if (skb_dst(skb))
622 neigh = skb_dst(skb)->neighbour; 648 neigh = skb_dst(skb)->neighbour;
623 649
624 if (neigh == NULL) { 650 if (neigh == NULL) {
625 if (net_ratelimit()) 651 if (net_ratelimit())
626 printk(KERN_DEBUG "sit: nexthop == NULL\n"); 652 printk(KERN_DEBUG "sit: nexthop == NULL\n");
627 goto tx_error; 653 goto tx_error;
628 } 654 }
629 655
630 addr6 = (struct in6_addr*)&neigh->primary_key; 656 addr6 = (struct in6_addr*)&neigh->primary_key;
631 addr_type = ipv6_addr_type(addr6); 657 addr_type = ipv6_addr_type(addr6);
632 658
633 if ((addr_type & IPV6_ADDR_UNICAST) && 659 if ((addr_type & IPV6_ADDR_UNICAST) &&
634 ipv6_addr_is_isatap(addr6)) 660 ipv6_addr_is_isatap(addr6))
635 dst = addr6->s6_addr32[3]; 661 dst = addr6->s6_addr32[3];
636 else 662 else
637 goto tx_error; 663 goto tx_error;
638 } 664 }
639 665
640 if (!dst) 666 if (!dst)
641 dst = try_6rd(&iph6->daddr, tunnel); 667 dst = try_6rd(&iph6->daddr, tunnel);
642 668
643 if (!dst) { 669 if (!dst) {
644 struct neighbour *neigh = NULL; 670 struct neighbour *neigh = NULL;
645 671
646 if (skb_dst(skb)) 672 if (skb_dst(skb))
647 neigh = skb_dst(skb)->neighbour; 673 neigh = skb_dst(skb)->neighbour;
648 674
649 if (neigh == NULL) { 675 if (neigh == NULL) {
650 if (net_ratelimit()) 676 if (net_ratelimit())
651 printk(KERN_DEBUG "sit: nexthop == NULL\n"); 677 printk(KERN_DEBUG "sit: nexthop == NULL\n");
652 goto tx_error; 678 goto tx_error;
653 } 679 }
654 680
655 addr6 = (struct in6_addr*)&neigh->primary_key; 681 addr6 = (struct in6_addr*)&neigh->primary_key;
656 addr_type = ipv6_addr_type(addr6); 682 addr_type = ipv6_addr_type(addr6);
657 683
658 if (addr_type == IPV6_ADDR_ANY) { 684 if (addr_type == IPV6_ADDR_ANY) {
659 addr6 = &ipv6_hdr(skb)->daddr; 685 addr6 = &ipv6_hdr(skb)->daddr;
660 addr_type = ipv6_addr_type(addr6); 686 addr_type = ipv6_addr_type(addr6);
661 } 687 }
662 688
663 if ((addr_type & IPV6_ADDR_COMPATv4) == 0) 689 if ((addr_type & IPV6_ADDR_COMPATv4) == 0)
664 goto tx_error_icmp; 690 goto tx_error_icmp;
665 691
666 dst = addr6->s6_addr32[3]; 692 dst = addr6->s6_addr32[3];
667 } 693 }
668 694
669 { 695 {
670 struct flowi fl = { .nl_u = { .ip4_u = 696 struct flowi fl = { .nl_u = { .ip4_u =
671 { .daddr = dst, 697 { .daddr = dst,
672 .saddr = tiph->saddr, 698 .saddr = tiph->saddr,
673 .tos = RT_TOS(tos) } }, 699 .tos = RT_TOS(tos) } },
674 .oif = tunnel->parms.link, 700 .oif = tunnel->parms.link,
675 .proto = IPPROTO_IPV6 }; 701 .proto = IPPROTO_IPV6 };
676 if (ip_route_output_key(dev_net(dev), &rt, &fl)) { 702 if (ip_route_output_key(dev_net(dev), &rt, &fl)) {
677 stats->tx_carrier_errors++; 703 stats->tx_carrier_errors++;
678 goto tx_error_icmp; 704 goto tx_error_icmp;
679 } 705 }
680 } 706 }
681 if (rt->rt_type != RTN_UNICAST) { 707 if (rt->rt_type != RTN_UNICAST) {
682 ip_rt_put(rt); 708 ip_rt_put(rt);
683 stats->tx_carrier_errors++; 709 stats->tx_carrier_errors++;
684 goto tx_error_icmp; 710 goto tx_error_icmp;
685 } 711 }
686 tdev = rt->u.dst.dev; 712 tdev = rt->u.dst.dev;
687 713
688 if (tdev == dev) { 714 if (tdev == dev) {
689 ip_rt_put(rt); 715 ip_rt_put(rt);
690 stats->collisions++; 716 stats->collisions++;
691 goto tx_error; 717 goto tx_error;
692 } 718 }
693 719
694 if (tiph->frag_off) 720 if (tiph->frag_off)
695 mtu = dst_mtu(&rt->u.dst) - sizeof(struct iphdr); 721 mtu = dst_mtu(&rt->u.dst) - sizeof(struct iphdr);
696 else 722 else
697 mtu = skb_dst(skb) ? dst_mtu(skb_dst(skb)) : dev->mtu; 723 mtu = skb_dst(skb) ? dst_mtu(skb_dst(skb)) : dev->mtu;
698 724
699 if (mtu < 68) { 725 if (mtu < 68) {
700 stats->collisions++; 726 stats->collisions++;
701 ip_rt_put(rt); 727 ip_rt_put(rt);
702 goto tx_error; 728 goto tx_error;
703 } 729 }
704 if (mtu < IPV6_MIN_MTU) 730 if (mtu < IPV6_MIN_MTU)
705 mtu = IPV6_MIN_MTU; 731 mtu = IPV6_MIN_MTU;
706 if (tunnel->parms.iph.daddr && skb_dst(skb)) 732 if (tunnel->parms.iph.daddr && skb_dst(skb))
707 skb_dst(skb)->ops->update_pmtu(skb_dst(skb), mtu); 733 skb_dst(skb)->ops->update_pmtu(skb_dst(skb), mtu);
708 734
709 if (skb->len > mtu) { 735 if (skb->len > mtu) {
710 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu, dev); 736 icmpv6_send(skb, ICMPV6_PKT_TOOBIG, 0, mtu, dev);
711 ip_rt_put(rt); 737 ip_rt_put(rt);
712 goto tx_error; 738 goto tx_error;
713 } 739 }
714 740
715 if (tunnel->err_count > 0) { 741 if (tunnel->err_count > 0) {
716 if (time_before(jiffies, 742 if (time_before(jiffies,
717 tunnel->err_time + IPTUNNEL_ERR_TIMEO)) { 743 tunnel->err_time + IPTUNNEL_ERR_TIMEO)) {
718 tunnel->err_count--; 744 tunnel->err_count--;
719 dst_link_failure(skb); 745 dst_link_failure(skb);
720 } else 746 } else
721 tunnel->err_count = 0; 747 tunnel->err_count = 0;
722 } 748 }
723 749
724 /* 750 /*
725 * Okay, now see if we can stuff it in the buffer as-is. 751 * Okay, now see if we can stuff it in the buffer as-is.
726 */ 752 */
727 max_headroom = LL_RESERVED_SPACE(tdev)+sizeof(struct iphdr); 753 max_headroom = LL_RESERVED_SPACE(tdev)+sizeof(struct iphdr);
728 754
729 if (skb_headroom(skb) < max_headroom || skb_shared(skb) || 755 if (skb_headroom(skb) < max_headroom || skb_shared(skb) ||
730 (skb_cloned(skb) && !skb_clone_writable(skb, 0))) { 756 (skb_cloned(skb) && !skb_clone_writable(skb, 0))) {
731 struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom); 757 struct sk_buff *new_skb = skb_realloc_headroom(skb, max_headroom);
732 if (!new_skb) { 758 if (!new_skb) {
733 ip_rt_put(rt); 759 ip_rt_put(rt);
734 txq->tx_dropped++; 760 txq->tx_dropped++;
735 dev_kfree_skb(skb); 761 dev_kfree_skb(skb);
736 return NETDEV_TX_OK; 762 return NETDEV_TX_OK;
737 } 763 }
738 if (skb->sk) 764 if (skb->sk)
739 skb_set_owner_w(new_skb, skb->sk); 765 skb_set_owner_w(new_skb, skb->sk);
740 dev_kfree_skb(skb); 766 dev_kfree_skb(skb);
741 skb = new_skb; 767 skb = new_skb;
742 iph6 = ipv6_hdr(skb); 768 iph6 = ipv6_hdr(skb);
743 } 769 }
744 770
745 skb->transport_header = skb->network_header; 771 skb->transport_header = skb->network_header;
746 skb_push(skb, sizeof(struct iphdr)); 772 skb_push(skb, sizeof(struct iphdr));
747 skb_reset_network_header(skb); 773 skb_reset_network_header(skb);
748 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt)); 774 memset(&(IPCB(skb)->opt), 0, sizeof(IPCB(skb)->opt));
749 IPCB(skb)->flags = 0; 775 IPCB(skb)->flags = 0;
750 skb_dst_drop(skb); 776 skb_dst_drop(skb);
751 skb_dst_set(skb, &rt->u.dst); 777 skb_dst_set(skb, &rt->u.dst);
752 778
753 /* 779 /*
754 * Push down and install the IPIP header. 780 * Push down and install the IPIP header.
755 */ 781 */
756 782
757 iph = ip_hdr(skb); 783 iph = ip_hdr(skb);
758 iph->version = 4; 784 iph->version = 4;
759 iph->ihl = sizeof(struct iphdr)>>2; 785 iph->ihl = sizeof(struct iphdr)>>2;
760 if (mtu > IPV6_MIN_MTU) 786 if (mtu > IPV6_MIN_MTU)
761 iph->frag_off = tiph->frag_off; 787 iph->frag_off = tiph->frag_off;
762 else 788 else
763 iph->frag_off = 0; 789 iph->frag_off = 0;
764 790
765 iph->protocol = IPPROTO_IPV6; 791 iph->protocol = IPPROTO_IPV6;
766 iph->tos = INET_ECN_encapsulate(tos, ipv6_get_dsfield(iph6)); 792 iph->tos = INET_ECN_encapsulate(tos, ipv6_get_dsfield(iph6));
767 iph->daddr = rt->rt_dst; 793 iph->daddr = rt->rt_dst;
768 iph->saddr = rt->rt_src; 794 iph->saddr = rt->rt_src;
769 795
770 if ((iph->ttl = tiph->ttl) == 0) 796 if ((iph->ttl = tiph->ttl) == 0)
771 iph->ttl = iph6->hop_limit; 797 iph->ttl = iph6->hop_limit;
772 798
773 nf_reset(skb); 799 nf_reset(skb);
774 800
775 IPTUNNEL_XMIT(); 801 IPTUNNEL_XMIT();
776 return NETDEV_TX_OK; 802 return NETDEV_TX_OK;
777 803
778 tx_error_icmp: 804 tx_error_icmp:
779 dst_link_failure(skb); 805 dst_link_failure(skb);
780 tx_error: 806 tx_error:
781 stats->tx_errors++; 807 stats->tx_errors++;
782 dev_kfree_skb(skb); 808 dev_kfree_skb(skb);
783 return NETDEV_TX_OK; 809 return NETDEV_TX_OK;
784 } 810 }
785 811
786 static void ipip6_tunnel_bind_dev(struct net_device *dev) 812 static void ipip6_tunnel_bind_dev(struct net_device *dev)
787 { 813 {
788 struct net_device *tdev = NULL; 814 struct net_device *tdev = NULL;
789 struct ip_tunnel *tunnel; 815 struct ip_tunnel *tunnel;
790 struct iphdr *iph; 816 struct iphdr *iph;
791 817
792 tunnel = netdev_priv(dev); 818 tunnel = netdev_priv(dev);
793 iph = &tunnel->parms.iph; 819 iph = &tunnel->parms.iph;
794 820
795 if (iph->daddr) { 821 if (iph->daddr) {
796 struct flowi fl = { .nl_u = { .ip4_u = 822 struct flowi fl = { .nl_u = { .ip4_u =
797 { .daddr = iph->daddr, 823 { .daddr = iph->daddr,
798 .saddr = iph->saddr, 824 .saddr = iph->saddr,
799 .tos = RT_TOS(iph->tos) } }, 825 .tos = RT_TOS(iph->tos) } },
800 .oif = tunnel->parms.link, 826 .oif = tunnel->parms.link,
801 .proto = IPPROTO_IPV6 }; 827 .proto = IPPROTO_IPV6 };
802 struct rtable *rt; 828 struct rtable *rt;
803 if (!ip_route_output_key(dev_net(dev), &rt, &fl)) { 829 if (!ip_route_output_key(dev_net(dev), &rt, &fl)) {
804 tdev = rt->u.dst.dev; 830 tdev = rt->u.dst.dev;
805 ip_rt_put(rt); 831 ip_rt_put(rt);
806 } 832 }
807 dev->flags |= IFF_POINTOPOINT; 833 dev->flags |= IFF_POINTOPOINT;
808 } 834 }
809 835
810 if (!tdev && tunnel->parms.link) 836 if (!tdev && tunnel->parms.link)
811 tdev = __dev_get_by_index(dev_net(dev), tunnel->parms.link); 837 tdev = __dev_get_by_index(dev_net(dev), tunnel->parms.link);
812 838
813 if (tdev) { 839 if (tdev) {
814 dev->hard_header_len = tdev->hard_header_len + sizeof(struct iphdr); 840 dev->hard_header_len = tdev->hard_header_len + sizeof(struct iphdr);
815 dev->mtu = tdev->mtu - sizeof(struct iphdr); 841 dev->mtu = tdev->mtu - sizeof(struct iphdr);
816 if (dev->mtu < IPV6_MIN_MTU) 842 if (dev->mtu < IPV6_MIN_MTU)
817 dev->mtu = IPV6_MIN_MTU; 843 dev->mtu = IPV6_MIN_MTU;
818 } 844 }
819 dev->iflink = tunnel->parms.link; 845 dev->iflink = tunnel->parms.link;
820 } 846 }
821 847
822 static int 848 static int
823 ipip6_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd) 849 ipip6_tunnel_ioctl (struct net_device *dev, struct ifreq *ifr, int cmd)
824 { 850 {
825 int err = 0; 851 int err = 0;
826 struct ip_tunnel_parm p; 852 struct ip_tunnel_parm p;
827 struct ip_tunnel_prl prl; 853 struct ip_tunnel_prl prl;
828 struct ip_tunnel *t; 854 struct ip_tunnel *t;
829 struct net *net = dev_net(dev); 855 struct net *net = dev_net(dev);
830 struct sit_net *sitn = net_generic(net, sit_net_id); 856 struct sit_net *sitn = net_generic(net, sit_net_id);
831 #ifdef CONFIG_IPV6_SIT_6RD 857 #ifdef CONFIG_IPV6_SIT_6RD
832 struct ip_tunnel_6rd ip6rd; 858 struct ip_tunnel_6rd ip6rd;
833 #endif 859 #endif
834 860
835 switch (cmd) { 861 switch (cmd) {
836 case SIOCGETTUNNEL: 862 case SIOCGETTUNNEL:
837 #ifdef CONFIG_IPV6_SIT_6RD 863 #ifdef CONFIG_IPV6_SIT_6RD
838 case SIOCGET6RD: 864 case SIOCGET6RD:
839 #endif 865 #endif
840 t = NULL; 866 t = NULL;
841 if (dev == sitn->fb_tunnel_dev) { 867 if (dev == sitn->fb_tunnel_dev) {
842 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) { 868 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) {
843 err = -EFAULT; 869 err = -EFAULT;
844 break; 870 break;
845 } 871 }
846 t = ipip6_tunnel_locate(net, &p, 0); 872 t = ipip6_tunnel_locate(net, &p, 0);
847 } 873 }
848 if (t == NULL) 874 if (t == NULL)
849 t = netdev_priv(dev); 875 t = netdev_priv(dev);
850 876
851 err = -EFAULT; 877 err = -EFAULT;
852 if (cmd == SIOCGETTUNNEL) { 878 if (cmd == SIOCGETTUNNEL) {
853 memcpy(&p, &t->parms, sizeof(p)); 879 memcpy(&p, &t->parms, sizeof(p));
854 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p, 880 if (copy_to_user(ifr->ifr_ifru.ifru_data, &p,
855 sizeof(p))) 881 sizeof(p)))
856 goto done; 882 goto done;
857 #ifdef CONFIG_IPV6_SIT_6RD 883 #ifdef CONFIG_IPV6_SIT_6RD
858 } else { 884 } else {
859 ipv6_addr_copy(&ip6rd.prefix, &t->ip6rd.prefix); 885 ipv6_addr_copy(&ip6rd.prefix, &t->ip6rd.prefix);
860 ip6rd.relay_prefix = t->ip6rd.relay_prefix; 886 ip6rd.relay_prefix = t->ip6rd.relay_prefix;
861 ip6rd.prefixlen = t->ip6rd.prefixlen; 887 ip6rd.prefixlen = t->ip6rd.prefixlen;
862 ip6rd.relay_prefixlen = t->ip6rd.relay_prefixlen; 888 ip6rd.relay_prefixlen = t->ip6rd.relay_prefixlen;
863 if (copy_to_user(ifr->ifr_ifru.ifru_data, &ip6rd, 889 if (copy_to_user(ifr->ifr_ifru.ifru_data, &ip6rd,
864 sizeof(ip6rd))) 890 sizeof(ip6rd)))
865 goto done; 891 goto done;
866 #endif 892 #endif
867 } 893 }
868 err = 0; 894 err = 0;
869 break; 895 break;
870 896
871 case SIOCADDTUNNEL: 897 case SIOCADDTUNNEL:
872 case SIOCCHGTUNNEL: 898 case SIOCCHGTUNNEL:
873 err = -EPERM; 899 err = -EPERM;
874 if (!capable(CAP_NET_ADMIN)) 900 if (!capable(CAP_NET_ADMIN))
875 goto done; 901 goto done;
876 902
877 err = -EFAULT; 903 err = -EFAULT;
878 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) 904 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
879 goto done; 905 goto done;
880 906
881 err = -EINVAL; 907 err = -EINVAL;
882 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_IPV6 || 908 if (p.iph.version != 4 || p.iph.protocol != IPPROTO_IPV6 ||
883 p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF))) 909 p.iph.ihl != 5 || (p.iph.frag_off&htons(~IP_DF)))
884 goto done; 910 goto done;
885 if (p.iph.ttl) 911 if (p.iph.ttl)
886 p.iph.frag_off |= htons(IP_DF); 912 p.iph.frag_off |= htons(IP_DF);
887 913
888 t = ipip6_tunnel_locate(net, &p, cmd == SIOCADDTUNNEL); 914 t = ipip6_tunnel_locate(net, &p, cmd == SIOCADDTUNNEL);
889 915
890 if (dev != sitn->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) { 916 if (dev != sitn->fb_tunnel_dev && cmd == SIOCCHGTUNNEL) {
891 if (t != NULL) { 917 if (t != NULL) {
892 if (t->dev != dev) { 918 if (t->dev != dev) {
893 err = -EEXIST; 919 err = -EEXIST;
894 break; 920 break;
895 } 921 }
896 } else { 922 } else {
897 if (((dev->flags&IFF_POINTOPOINT) && !p.iph.daddr) || 923 if (((dev->flags&IFF_POINTOPOINT) && !p.iph.daddr) ||
898 (!(dev->flags&IFF_POINTOPOINT) && p.iph.daddr)) { 924 (!(dev->flags&IFF_POINTOPOINT) && p.iph.daddr)) {
899 err = -EINVAL; 925 err = -EINVAL;
900 break; 926 break;
901 } 927 }
902 t = netdev_priv(dev); 928 t = netdev_priv(dev);
903 ipip6_tunnel_unlink(sitn, t); 929 ipip6_tunnel_unlink(sitn, t);
904 t->parms.iph.saddr = p.iph.saddr; 930 t->parms.iph.saddr = p.iph.saddr;
905 t->parms.iph.daddr = p.iph.daddr; 931 t->parms.iph.daddr = p.iph.daddr;
906 memcpy(dev->dev_addr, &p.iph.saddr, 4); 932 memcpy(dev->dev_addr, &p.iph.saddr, 4);
907 memcpy(dev->broadcast, &p.iph.daddr, 4); 933 memcpy(dev->broadcast, &p.iph.daddr, 4);
908 ipip6_tunnel_link(sitn, t); 934 ipip6_tunnel_link(sitn, t);
909 netdev_state_change(dev); 935 netdev_state_change(dev);
910 } 936 }
911 } 937 }
912 938
913 if (t) { 939 if (t) {
914 err = 0; 940 err = 0;
915 if (cmd == SIOCCHGTUNNEL) { 941 if (cmd == SIOCCHGTUNNEL) {
916 t->parms.iph.ttl = p.iph.ttl; 942 t->parms.iph.ttl = p.iph.ttl;
917 t->parms.iph.tos = p.iph.tos; 943 t->parms.iph.tos = p.iph.tos;
918 if (t->parms.link != p.link) { 944 if (t->parms.link != p.link) {
919 t->parms.link = p.link; 945 t->parms.link = p.link;
920 ipip6_tunnel_bind_dev(dev); 946 ipip6_tunnel_bind_dev(dev);
921 netdev_state_change(dev); 947 netdev_state_change(dev);
922 } 948 }
923 } 949 }
924 if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p))) 950 if (copy_to_user(ifr->ifr_ifru.ifru_data, &t->parms, sizeof(p)))
925 err = -EFAULT; 951 err = -EFAULT;
926 } else 952 } else
927 err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT); 953 err = (cmd == SIOCADDTUNNEL ? -ENOBUFS : -ENOENT);
928 break; 954 break;
929 955
930 case SIOCDELTUNNEL: 956 case SIOCDELTUNNEL:
931 err = -EPERM; 957 err = -EPERM;
932 if (!capable(CAP_NET_ADMIN)) 958 if (!capable(CAP_NET_ADMIN))
933 goto done; 959 goto done;
934 960
935 if (dev == sitn->fb_tunnel_dev) { 961 if (dev == sitn->fb_tunnel_dev) {
936 err = -EFAULT; 962 err = -EFAULT;
937 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p))) 963 if (copy_from_user(&p, ifr->ifr_ifru.ifru_data, sizeof(p)))
938 goto done; 964 goto done;
939 err = -ENOENT; 965 err = -ENOENT;
940 if ((t = ipip6_tunnel_locate(net, &p, 0)) == NULL) 966 if ((t = ipip6_tunnel_locate(net, &p, 0)) == NULL)
941 goto done; 967 goto done;
942 err = -EPERM; 968 err = -EPERM;
943 if (t == netdev_priv(sitn->fb_tunnel_dev)) 969 if (t == netdev_priv(sitn->fb_tunnel_dev))
944 goto done; 970 goto done;
945 dev = t->dev; 971 dev = t->dev;
946 } 972 }
947 unregister_netdevice(dev); 973 unregister_netdevice(dev);
948 err = 0; 974 err = 0;
949 break; 975 break;
950 976
951 case SIOCGETPRL: 977 case SIOCGETPRL:
952 err = -EINVAL; 978 err = -EINVAL;
953 if (dev == sitn->fb_tunnel_dev) 979 if (dev == sitn->fb_tunnel_dev)
954 goto done; 980 goto done;
955 err = -ENOENT; 981 err = -ENOENT;
956 if (!(t = netdev_priv(dev))) 982 if (!(t = netdev_priv(dev)))
957 goto done; 983 goto done;
958 err = ipip6_tunnel_get_prl(t, ifr->ifr_ifru.ifru_data); 984 err = ipip6_tunnel_get_prl(t, ifr->ifr_ifru.ifru_data);
959 break; 985 break;
960 986
961 case SIOCADDPRL: 987 case SIOCADDPRL:
962 case SIOCDELPRL: 988 case SIOCDELPRL:
963 case SIOCCHGPRL: 989 case SIOCCHGPRL:
964 err = -EPERM; 990 err = -EPERM;
965 if (!capable(CAP_NET_ADMIN)) 991 if (!capable(CAP_NET_ADMIN))
966 goto done; 992 goto done;
967 err = -EINVAL; 993 err = -EINVAL;
968 if (dev == sitn->fb_tunnel_dev) 994 if (dev == sitn->fb_tunnel_dev)
969 goto done; 995 goto done;
970 err = -EFAULT; 996 err = -EFAULT;
971 if (copy_from_user(&prl, ifr->ifr_ifru.ifru_data, sizeof(prl))) 997 if (copy_from_user(&prl, ifr->ifr_ifru.ifru_data, sizeof(prl)))
972 goto done; 998 goto done;
973 err = -ENOENT; 999 err = -ENOENT;
974 if (!(t = netdev_priv(dev))) 1000 if (!(t = netdev_priv(dev)))
975 goto done; 1001 goto done;
976 1002
977 switch (cmd) { 1003 switch (cmd) {
978 case SIOCDELPRL: 1004 case SIOCDELPRL:
979 err = ipip6_tunnel_del_prl(t, &prl); 1005 err = ipip6_tunnel_del_prl(t, &prl);
980 break; 1006 break;
981 case SIOCADDPRL: 1007 case SIOCADDPRL:
982 case SIOCCHGPRL: 1008 case SIOCCHGPRL:
983 err = ipip6_tunnel_add_prl(t, &prl, cmd == SIOCCHGPRL); 1009 err = ipip6_tunnel_add_prl(t, &prl, cmd == SIOCCHGPRL);
984 break; 1010 break;
985 } 1011 }
986 netdev_state_change(dev); 1012 netdev_state_change(dev);
987 break; 1013 break;
988 1014
989 #ifdef CONFIG_IPV6_SIT_6RD 1015 #ifdef CONFIG_IPV6_SIT_6RD
990 case SIOCADD6RD: 1016 case SIOCADD6RD:
991 case SIOCCHG6RD: 1017 case SIOCCHG6RD:
992 case SIOCDEL6RD: 1018 case SIOCDEL6RD:
993 err = -EPERM; 1019 err = -EPERM;
994 if (!capable(CAP_NET_ADMIN)) 1020 if (!capable(CAP_NET_ADMIN))
995 goto done; 1021 goto done;
996 1022
997 err = -EFAULT; 1023 err = -EFAULT;
998 if (copy_from_user(&ip6rd, ifr->ifr_ifru.ifru_data, 1024 if (copy_from_user(&ip6rd, ifr->ifr_ifru.ifru_data,
999 sizeof(ip6rd))) 1025 sizeof(ip6rd)))
1000 goto done; 1026 goto done;
1001 1027
1002 t = netdev_priv(dev); 1028 t = netdev_priv(dev);
1003 1029
1004 if (cmd != SIOCDEL6RD) { 1030 if (cmd != SIOCDEL6RD) {
1005 struct in6_addr prefix; 1031 struct in6_addr prefix;
1006 __be32 relay_prefix; 1032 __be32 relay_prefix;
1007 1033
1008 err = -EINVAL; 1034 err = -EINVAL;
1009 if (ip6rd.relay_prefixlen > 32 || 1035 if (ip6rd.relay_prefixlen > 32 ||
1010 ip6rd.prefixlen + (32 - ip6rd.relay_prefixlen) > 64) 1036 ip6rd.prefixlen + (32 - ip6rd.relay_prefixlen) > 64)
1011 goto done; 1037 goto done;
1012 1038
1013 ipv6_addr_prefix(&prefix, &ip6rd.prefix, 1039 ipv6_addr_prefix(&prefix, &ip6rd.prefix,
1014 ip6rd.prefixlen); 1040 ip6rd.prefixlen);
1015 if (!ipv6_addr_equal(&prefix, &ip6rd.prefix)) 1041 if (!ipv6_addr_equal(&prefix, &ip6rd.prefix))
1016 goto done; 1042 goto done;
1017 if (ip6rd.relay_prefixlen) 1043 if (ip6rd.relay_prefixlen)
1018 relay_prefix = ip6rd.relay_prefix & 1044 relay_prefix = ip6rd.relay_prefix &
1019 htonl(0xffffffffUL << 1045 htonl(0xffffffffUL <<
1020 (32 - ip6rd.relay_prefixlen)); 1046 (32 - ip6rd.relay_prefixlen));
1021 else 1047 else
1022 relay_prefix = 0; 1048 relay_prefix = 0;
1023 if (relay_prefix != ip6rd.relay_prefix) 1049 if (relay_prefix != ip6rd.relay_prefix)
1024 goto done; 1050 goto done;
1025 1051
1026 ipv6_addr_copy(&t->ip6rd.prefix, &prefix); 1052 ipv6_addr_copy(&t->ip6rd.prefix, &prefix);
1027 t->ip6rd.relay_prefix = relay_prefix; 1053 t->ip6rd.relay_prefix = relay_prefix;
1028 t->ip6rd.prefixlen = ip6rd.prefixlen; 1054 t->ip6rd.prefixlen = ip6rd.prefixlen;
1029 t->ip6rd.relay_prefixlen = ip6rd.relay_prefixlen; 1055 t->ip6rd.relay_prefixlen = ip6rd.relay_prefixlen;
1030 } else 1056 } else
1031 ipip6_tunnel_clone_6rd(dev, sitn); 1057 ipip6_tunnel_clone_6rd(dev, sitn);
1032 1058
1033 err = 0; 1059 err = 0;
1034 break; 1060 break;
1035 #endif 1061 #endif
1036 1062
1037 default: 1063 default:
1038 err = -EINVAL; 1064 err = -EINVAL;
1039 } 1065 }
1040 1066
1041 done: 1067 done:
1042 return err; 1068 return err;
1043 } 1069 }
1044 1070
1045 static int ipip6_tunnel_change_mtu(struct net_device *dev, int new_mtu) 1071 static int ipip6_tunnel_change_mtu(struct net_device *dev, int new_mtu)
1046 { 1072 {
1047 if (new_mtu < IPV6_MIN_MTU || new_mtu > 0xFFF8 - sizeof(struct iphdr)) 1073 if (new_mtu < IPV6_MIN_MTU || new_mtu > 0xFFF8 - sizeof(struct iphdr))
1048 return -EINVAL; 1074 return -EINVAL;
1049 dev->mtu = new_mtu; 1075 dev->mtu = new_mtu;
1050 return 0; 1076 return 0;
1051 } 1077 }
1052 1078
1053 static const struct net_device_ops ipip6_netdev_ops = { 1079 static const struct net_device_ops ipip6_netdev_ops = {
1054 .ndo_uninit = ipip6_tunnel_uninit, 1080 .ndo_uninit = ipip6_tunnel_uninit,
1055 .ndo_start_xmit = ipip6_tunnel_xmit, 1081 .ndo_start_xmit = ipip6_tunnel_xmit,
1056 .ndo_do_ioctl = ipip6_tunnel_ioctl, 1082 .ndo_do_ioctl = ipip6_tunnel_ioctl,
1057 .ndo_change_mtu = ipip6_tunnel_change_mtu, 1083 .ndo_change_mtu = ipip6_tunnel_change_mtu,
1058 }; 1084 };
1059 1085
1060 static void ipip6_tunnel_setup(struct net_device *dev) 1086 static void ipip6_tunnel_setup(struct net_device *dev)
1061 { 1087 {
1062 dev->netdev_ops = &ipip6_netdev_ops; 1088 dev->netdev_ops = &ipip6_netdev_ops;
1063 dev->destructor = free_netdev; 1089 dev->destructor = free_netdev;
1064 1090
1065 dev->type = ARPHRD_SIT; 1091 dev->type = ARPHRD_SIT;
1066 dev->hard_header_len = LL_MAX_HEADER + sizeof(struct iphdr); 1092 dev->hard_header_len = LL_MAX_HEADER + sizeof(struct iphdr);
1067 dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr); 1093 dev->mtu = ETH_DATA_LEN - sizeof(struct iphdr);
1068 dev->flags = IFF_NOARP; 1094 dev->flags = IFF_NOARP;
1069 dev->priv_flags &= ~IFF_XMIT_DST_RELEASE; 1095 dev->priv_flags &= ~IFF_XMIT_DST_RELEASE;
1070 dev->iflink = 0; 1096 dev->iflink = 0;
1071 dev->addr_len = 4; 1097 dev->addr_len = 4;
1072 dev->features |= NETIF_F_NETNS_LOCAL; 1098 dev->features |= NETIF_F_NETNS_LOCAL;
1073 } 1099 }
1074 1100
1075 static void ipip6_tunnel_init(struct net_device *dev) 1101 static void ipip6_tunnel_init(struct net_device *dev)
1076 { 1102 {
1077 struct ip_tunnel *tunnel = netdev_priv(dev); 1103 struct ip_tunnel *tunnel = netdev_priv(dev);
1078 1104
1079 tunnel->dev = dev; 1105 tunnel->dev = dev;
1080 strcpy(tunnel->parms.name, dev->name); 1106 strcpy(tunnel->parms.name, dev->name);
1081 1107
1082 memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4); 1108 memcpy(dev->dev_addr, &tunnel->parms.iph.saddr, 4);
1083 memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4); 1109 memcpy(dev->broadcast, &tunnel->parms.iph.daddr, 4);
1084 1110
1085 ipip6_tunnel_bind_dev(dev); 1111 ipip6_tunnel_bind_dev(dev);
1086 } 1112 }
1087 1113
1088 static void ipip6_fb_tunnel_init(struct net_device *dev) 1114 static void ipip6_fb_tunnel_init(struct net_device *dev)
1089 { 1115 {
1090 struct ip_tunnel *tunnel = netdev_priv(dev); 1116 struct ip_tunnel *tunnel = netdev_priv(dev);
1091 struct iphdr *iph = &tunnel->parms.iph; 1117 struct iphdr *iph = &tunnel->parms.iph;
1092 struct net *net = dev_net(dev); 1118 struct net *net = dev_net(dev);
1093 struct sit_net *sitn = net_generic(net, sit_net_id); 1119 struct sit_net *sitn = net_generic(net, sit_net_id);
1094 1120
1095 tunnel->dev = dev; 1121 tunnel->dev = dev;
1096 strcpy(tunnel->parms.name, dev->name); 1122 strcpy(tunnel->parms.name, dev->name);
1097 1123
1098 iph->version = 4; 1124 iph->version = 4;
1099 iph->protocol = IPPROTO_IPV6; 1125 iph->protocol = IPPROTO_IPV6;
1100 iph->ihl = 5; 1126 iph->ihl = 5;
1101 iph->ttl = 64; 1127 iph->ttl = 64;
1102 1128
1103 dev_hold(dev); 1129 dev_hold(dev);
1104 sitn->tunnels_wc[0] = tunnel; 1130 sitn->tunnels_wc[0] = tunnel;
1105 } 1131 }
1106 1132
1107 static struct xfrm_tunnel sit_handler = { 1133 static struct xfrm_tunnel sit_handler = {
1108 .handler = ipip6_rcv, 1134 .handler = ipip6_rcv,
1109 .err_handler = ipip6_err, 1135 .err_handler = ipip6_err,
1110 .priority = 1, 1136 .priority = 1,
1111 }; 1137 };
1112 1138
1113 static void sit_destroy_tunnels(struct sit_net *sitn) 1139 static void sit_destroy_tunnels(struct sit_net *sitn)
1114 { 1140 {
1115 int prio; 1141 int prio;
1116 1142
1117 for (prio = 1; prio < 4; prio++) { 1143 for (prio = 1; prio < 4; prio++) {
1118 int h; 1144 int h;
1119 for (h = 0; h < HASH_SIZE; h++) { 1145 for (h = 0; h < HASH_SIZE; h++) {
1120 struct ip_tunnel *t; 1146 struct ip_tunnel *t;
1121 while ((t = sitn->tunnels[prio][h]) != NULL) 1147 while ((t = sitn->tunnels[prio][h]) != NULL)
1122 unregister_netdevice(t->dev); 1148 unregister_netdevice(t->dev);
1123 } 1149 }
1124 } 1150 }
1125 } 1151 }
1126 1152
1127 static int sit_init_net(struct net *net) 1153 static int sit_init_net(struct net *net)
1128 { 1154 {
1129 int err; 1155 int err;
1130 struct sit_net *sitn; 1156 struct sit_net *sitn;
1131 1157
1132 err = -ENOMEM; 1158 err = -ENOMEM;
1133 sitn = kzalloc(sizeof(struct sit_net), GFP_KERNEL); 1159 sitn = kzalloc(sizeof(struct sit_net), GFP_KERNEL);
1134 if (sitn == NULL) 1160 if (sitn == NULL)
1135 goto err_alloc; 1161 goto err_alloc;
1136 1162
1137 err = net_assign_generic(net, sit_net_id, sitn); 1163 err = net_assign_generic(net, sit_net_id, sitn);
1138 if (err < 0) 1164 if (err < 0)
1139 goto err_assign; 1165 goto err_assign;
1140 1166
1141 sitn->tunnels[0] = sitn->tunnels_wc; 1167 sitn->tunnels[0] = sitn->tunnels_wc;
1142 sitn->tunnels[1] = sitn->tunnels_l; 1168 sitn->tunnels[1] = sitn->tunnels_l;
1143 sitn->tunnels[2] = sitn->tunnels_r; 1169 sitn->tunnels[2] = sitn->tunnels_r;
1144 sitn->tunnels[3] = sitn->tunnels_r_l; 1170 sitn->tunnels[3] = sitn->tunnels_r_l;
1145 1171
1146 sitn->fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel), "sit0", 1172 sitn->fb_tunnel_dev = alloc_netdev(sizeof(struct ip_tunnel), "sit0",
1147 ipip6_tunnel_setup); 1173 ipip6_tunnel_setup);
1148 if (!sitn->fb_tunnel_dev) { 1174 if (!sitn->fb_tunnel_dev) {
1149 err = -ENOMEM; 1175 err = -ENOMEM;
1150 goto err_alloc_dev; 1176 goto err_alloc_dev;
1151 } 1177 }
1152 dev_net_set(sitn->fb_tunnel_dev, net); 1178 dev_net_set(sitn->fb_tunnel_dev, net);
1153 1179
1154 ipip6_fb_tunnel_init(sitn->fb_tunnel_dev); 1180 ipip6_fb_tunnel_init(sitn->fb_tunnel_dev);
1155 ipip6_tunnel_clone_6rd(sitn->fb_tunnel_dev, sitn); 1181 ipip6_tunnel_clone_6rd(sitn->fb_tunnel_dev, sitn);
1156 1182
1157 if ((err = register_netdev(sitn->fb_tunnel_dev))) 1183 if ((err = register_netdev(sitn->fb_tunnel_dev)))
1158 goto err_reg_dev; 1184 goto err_reg_dev;
1159 1185
1160 return 0; 1186 return 0;
1161 1187
1162 err_reg_dev: 1188 err_reg_dev:
1163 dev_put(sitn->fb_tunnel_dev); 1189 dev_put(sitn->fb_tunnel_dev);
1164 free_netdev(sitn->fb_tunnel_dev); 1190 free_netdev(sitn->fb_tunnel_dev);
1165 err_alloc_dev: 1191 err_alloc_dev:
1166 /* nothing */ 1192 /* nothing */
1167 err_assign: 1193 err_assign:
1168 kfree(sitn); 1194 kfree(sitn);
1169 err_alloc: 1195 err_alloc:
1170 return err; 1196 return err;
1171 } 1197 }
1172 1198
1173 static void sit_exit_net(struct net *net) 1199 static void sit_exit_net(struct net *net)
1174 { 1200 {
1175 struct sit_net *sitn; 1201 struct sit_net *sitn;
1176 1202
1177 sitn = net_generic(net, sit_net_id); 1203 sitn = net_generic(net, sit_net_id);
1178 rtnl_lock(); 1204 rtnl_lock();
1179 sit_destroy_tunnels(sitn); 1205 sit_destroy_tunnels(sitn);
1180 unregister_netdevice(sitn->fb_tunnel_dev); 1206 unregister_netdevice(sitn->fb_tunnel_dev);
1181 rtnl_unlock(); 1207 rtnl_unlock();
1182 kfree(sitn); 1208 kfree(sitn);
1183 } 1209 }
1184 1210
1185 static struct pernet_operations sit_net_ops = { 1211 static struct pernet_operations sit_net_ops = {
1186 .init = sit_init_net, 1212 .init = sit_init_net,
1187 .exit = sit_exit_net, 1213 .exit = sit_exit_net,
1188 }; 1214 };
1189 1215
1190 static void __exit sit_cleanup(void) 1216 static void __exit sit_cleanup(void)
1191 { 1217 {
1192 xfrm4_tunnel_deregister(&sit_handler, AF_INET6); 1218 xfrm4_tunnel_deregister(&sit_handler, AF_INET6);
1193 1219
1194 unregister_pernet_gen_device(sit_net_id, &sit_net_ops); 1220 unregister_pernet_gen_device(sit_net_id, &sit_net_ops);
1221 rcu_barrier(); /* Wait for completion of call_rcu()'s */
1195 } 1222 }
1196 1223
1197 static int __init sit_init(void) 1224 static int __init sit_init(void)
1198 { 1225 {
1199 int err; 1226 int err;
1200 1227
1201 printk(KERN_INFO "IPv6 over IPv4 tunneling driver\n"); 1228 printk(KERN_INFO "IPv6 over IPv4 tunneling driver\n");
1202 1229
1203 if (xfrm4_tunnel_register(&sit_handler, AF_INET6) < 0) { 1230 if (xfrm4_tunnel_register(&sit_handler, AF_INET6) < 0) {
1204 printk(KERN_INFO "sit init: Can't add protocol\n"); 1231 printk(KERN_INFO "sit init: Can't add protocol\n");
1205 return -EAGAIN; 1232 return -EAGAIN;
1206 } 1233 }
1207 1234
1208 err = register_pernet_gen_device(&sit_net_id, &sit_net_ops); 1235 err = register_pernet_gen_device(&sit_net_id, &sit_net_ops);
1209 if (err < 0) 1236 if (err < 0)
1210 xfrm4_tunnel_deregister(&sit_handler, AF_INET6); 1237 xfrm4_tunnel_deregister(&sit_handler, AF_INET6);
1211 1238
1212 return err; 1239 return err;
1213 } 1240 }
1214 1241
1215 module_init(sit_init); 1242 module_init(sit_init);