Annotation of /trunk/kernel-magellan/patches-4.0/0100-4.0.1-all-fixes.patch
Parent Directory | Revision Log
Revision 2563 -
(hide annotations)
(download)
Tue Nov 25 22:54:01 2014 UTC (9 years, 10 months ago) by niro
File size: 14124 byte(s)
Tue Nov 25 22:54:01 2014 UTC (9 years, 10 months ago) by niro
File size: 14124 byte(s)
-linux-4.0.1
1 | niro | 2563 | diff --git a/Makefile b/Makefile |
2 | index fbd43bfe4445..f499cd2f5738 100644 | ||
3 | --- a/Makefile | ||
4 | +++ b/Makefile | ||
5 | @@ -1,6 +1,6 @@ | ||
6 | VERSION = 4 | ||
7 | PATCHLEVEL = 0 | ||
8 | -SUBLEVEL = 0 | ||
9 | +SUBLEVEL = 1 | ||
10 | EXTRAVERSION = | ||
11 | NAME = Hurr durr I'ma sheep | ||
12 | |||
13 | diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x.h b/drivers/net/ethernet/broadcom/bnx2x/bnx2x.h | ||
14 | index 4085c4b31047..355d5fea5be9 100644 | ||
15 | --- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x.h | ||
16 | +++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x.h | ||
17 | @@ -531,20 +531,8 @@ struct bnx2x_fastpath { | ||
18 | struct napi_struct napi; | ||
19 | |||
20 | #ifdef CONFIG_NET_RX_BUSY_POLL | ||
21 | - unsigned int state; | ||
22 | -#define BNX2X_FP_STATE_IDLE 0 | ||
23 | -#define BNX2X_FP_STATE_NAPI (1 << 0) /* NAPI owns this FP */ | ||
24 | -#define BNX2X_FP_STATE_POLL (1 << 1) /* poll owns this FP */ | ||
25 | -#define BNX2X_FP_STATE_DISABLED (1 << 2) | ||
26 | -#define BNX2X_FP_STATE_NAPI_YIELD (1 << 3) /* NAPI yielded this FP */ | ||
27 | -#define BNX2X_FP_STATE_POLL_YIELD (1 << 4) /* poll yielded this FP */ | ||
28 | -#define BNX2X_FP_OWNED (BNX2X_FP_STATE_NAPI | BNX2X_FP_STATE_POLL) | ||
29 | -#define BNX2X_FP_YIELD (BNX2X_FP_STATE_NAPI_YIELD | BNX2X_FP_STATE_POLL_YIELD) | ||
30 | -#define BNX2X_FP_LOCKED (BNX2X_FP_OWNED | BNX2X_FP_STATE_DISABLED) | ||
31 | -#define BNX2X_FP_USER_PEND (BNX2X_FP_STATE_POLL | BNX2X_FP_STATE_POLL_YIELD) | ||
32 | - /* protect state */ | ||
33 | - spinlock_t lock; | ||
34 | -#endif /* CONFIG_NET_RX_BUSY_POLL */ | ||
35 | + unsigned long busy_poll_state; | ||
36 | +#endif | ||
37 | |||
38 | union host_hc_status_block status_blk; | ||
39 | /* chip independent shortcuts into sb structure */ | ||
40 | @@ -619,104 +607,83 @@ struct bnx2x_fastpath { | ||
41 | #define bnx2x_fp_qstats(bp, fp) (&((bp)->fp_stats[(fp)->index].eth_q_stats)) | ||
42 | |||
43 | #ifdef CONFIG_NET_RX_BUSY_POLL | ||
44 | -static inline void bnx2x_fp_init_lock(struct bnx2x_fastpath *fp) | ||
45 | + | ||
46 | +enum bnx2x_fp_state { | ||
47 | + BNX2X_STATE_FP_NAPI = BIT(0), /* NAPI handler owns the queue */ | ||
48 | + | ||
49 | + BNX2X_STATE_FP_NAPI_REQ_BIT = 1, /* NAPI would like to own the queue */ | ||
50 | + BNX2X_STATE_FP_NAPI_REQ = BIT(1), | ||
51 | + | ||
52 | + BNX2X_STATE_FP_POLL_BIT = 2, | ||
53 | + BNX2X_STATE_FP_POLL = BIT(2), /* busy_poll owns the queue */ | ||
54 | + | ||
55 | + BNX2X_STATE_FP_DISABLE_BIT = 3, /* queue is dismantled */ | ||
56 | +}; | ||
57 | + | ||
58 | +static inline void bnx2x_fp_busy_poll_init(struct bnx2x_fastpath *fp) | ||
59 | { | ||
60 | - spin_lock_init(&fp->lock); | ||
61 | - fp->state = BNX2X_FP_STATE_IDLE; | ||
62 | + WRITE_ONCE(fp->busy_poll_state, 0); | ||
63 | } | ||
64 | |||
65 | /* called from the device poll routine to get ownership of a FP */ | ||
66 | static inline bool bnx2x_fp_lock_napi(struct bnx2x_fastpath *fp) | ||
67 | { | ||
68 | - bool rc = true; | ||
69 | - | ||
70 | - spin_lock_bh(&fp->lock); | ||
71 | - if (fp->state & BNX2X_FP_LOCKED) { | ||
72 | - WARN_ON(fp->state & BNX2X_FP_STATE_NAPI); | ||
73 | - fp->state |= BNX2X_FP_STATE_NAPI_YIELD; | ||
74 | - rc = false; | ||
75 | - } else { | ||
76 | - /* we don't care if someone yielded */ | ||
77 | - fp->state = BNX2X_FP_STATE_NAPI; | ||
78 | + unsigned long prev, old = READ_ONCE(fp->busy_poll_state); | ||
79 | + | ||
80 | + while (1) { | ||
81 | + switch (old) { | ||
82 | + case BNX2X_STATE_FP_POLL: | ||
83 | + /* make sure bnx2x_fp_lock_poll() wont starve us */ | ||
84 | + set_bit(BNX2X_STATE_FP_NAPI_REQ_BIT, | ||
85 | + &fp->busy_poll_state); | ||
86 | + /* fallthrough */ | ||
87 | + case BNX2X_STATE_FP_POLL | BNX2X_STATE_FP_NAPI_REQ: | ||
88 | + return false; | ||
89 | + default: | ||
90 | + break; | ||
91 | + } | ||
92 | + prev = cmpxchg(&fp->busy_poll_state, old, BNX2X_STATE_FP_NAPI); | ||
93 | + if (unlikely(prev != old)) { | ||
94 | + old = prev; | ||
95 | + continue; | ||
96 | + } | ||
97 | + return true; | ||
98 | } | ||
99 | - spin_unlock_bh(&fp->lock); | ||
100 | - return rc; | ||
101 | } | ||
102 | |||
103 | -/* returns true is someone tried to get the FP while napi had it */ | ||
104 | -static inline bool bnx2x_fp_unlock_napi(struct bnx2x_fastpath *fp) | ||
105 | +static inline void bnx2x_fp_unlock_napi(struct bnx2x_fastpath *fp) | ||
106 | { | ||
107 | - bool rc = false; | ||
108 | - | ||
109 | - spin_lock_bh(&fp->lock); | ||
110 | - WARN_ON(fp->state & | ||
111 | - (BNX2X_FP_STATE_POLL | BNX2X_FP_STATE_NAPI_YIELD)); | ||
112 | - | ||
113 | - if (fp->state & BNX2X_FP_STATE_POLL_YIELD) | ||
114 | - rc = true; | ||
115 | - | ||
116 | - /* state ==> idle, unless currently disabled */ | ||
117 | - fp->state &= BNX2X_FP_STATE_DISABLED; | ||
118 | - spin_unlock_bh(&fp->lock); | ||
119 | - return rc; | ||
120 | + smp_wmb(); | ||
121 | + fp->busy_poll_state = 0; | ||
122 | } | ||
123 | |||
124 | /* called from bnx2x_low_latency_poll() */ | ||
125 | static inline bool bnx2x_fp_lock_poll(struct bnx2x_fastpath *fp) | ||
126 | { | ||
127 | - bool rc = true; | ||
128 | - | ||
129 | - spin_lock_bh(&fp->lock); | ||
130 | - if ((fp->state & BNX2X_FP_LOCKED)) { | ||
131 | - fp->state |= BNX2X_FP_STATE_POLL_YIELD; | ||
132 | - rc = false; | ||
133 | - } else { | ||
134 | - /* preserve yield marks */ | ||
135 | - fp->state |= BNX2X_FP_STATE_POLL; | ||
136 | - } | ||
137 | - spin_unlock_bh(&fp->lock); | ||
138 | - return rc; | ||
139 | + return cmpxchg(&fp->busy_poll_state, 0, BNX2X_STATE_FP_POLL) == 0; | ||
140 | } | ||
141 | |||
142 | -/* returns true if someone tried to get the FP while it was locked */ | ||
143 | -static inline bool bnx2x_fp_unlock_poll(struct bnx2x_fastpath *fp) | ||
144 | +static inline void bnx2x_fp_unlock_poll(struct bnx2x_fastpath *fp) | ||
145 | { | ||
146 | - bool rc = false; | ||
147 | - | ||
148 | - spin_lock_bh(&fp->lock); | ||
149 | - WARN_ON(fp->state & BNX2X_FP_STATE_NAPI); | ||
150 | - | ||
151 | - if (fp->state & BNX2X_FP_STATE_POLL_YIELD) | ||
152 | - rc = true; | ||
153 | - | ||
154 | - /* state ==> idle, unless currently disabled */ | ||
155 | - fp->state &= BNX2X_FP_STATE_DISABLED; | ||
156 | - spin_unlock_bh(&fp->lock); | ||
157 | - return rc; | ||
158 | + smp_mb__before_atomic(); | ||
159 | + clear_bit(BNX2X_STATE_FP_POLL_BIT, &fp->busy_poll_state); | ||
160 | } | ||
161 | |||
162 | -/* true if a socket is polling, even if it did not get the lock */ | ||
163 | +/* true if a socket is polling */ | ||
164 | static inline bool bnx2x_fp_ll_polling(struct bnx2x_fastpath *fp) | ||
165 | { | ||
166 | - WARN_ON(!(fp->state & BNX2X_FP_OWNED)); | ||
167 | - return fp->state & BNX2X_FP_USER_PEND; | ||
168 | + return READ_ONCE(fp->busy_poll_state) & BNX2X_STATE_FP_POLL; | ||
169 | } | ||
170 | |||
171 | /* false if fp is currently owned */ | ||
172 | static inline bool bnx2x_fp_ll_disable(struct bnx2x_fastpath *fp) | ||
173 | { | ||
174 | - int rc = true; | ||
175 | - | ||
176 | - spin_lock_bh(&fp->lock); | ||
177 | - if (fp->state & BNX2X_FP_OWNED) | ||
178 | - rc = false; | ||
179 | - fp->state |= BNX2X_FP_STATE_DISABLED; | ||
180 | - spin_unlock_bh(&fp->lock); | ||
181 | + set_bit(BNX2X_STATE_FP_DISABLE_BIT, &fp->busy_poll_state); | ||
182 | + return !bnx2x_fp_ll_polling(fp); | ||
183 | |||
184 | - return rc; | ||
185 | } | ||
186 | #else | ||
187 | -static inline void bnx2x_fp_init_lock(struct bnx2x_fastpath *fp) | ||
188 | +static inline void bnx2x_fp_busy_poll_init(struct bnx2x_fastpath *fp) | ||
189 | { | ||
190 | } | ||
191 | |||
192 | @@ -725,9 +692,8 @@ static inline bool bnx2x_fp_lock_napi(struct bnx2x_fastpath *fp) | ||
193 | return true; | ||
194 | } | ||
195 | |||
196 | -static inline bool bnx2x_fp_unlock_napi(struct bnx2x_fastpath *fp) | ||
197 | +static inline void bnx2x_fp_unlock_napi(struct bnx2x_fastpath *fp) | ||
198 | { | ||
199 | - return false; | ||
200 | } | ||
201 | |||
202 | static inline bool bnx2x_fp_lock_poll(struct bnx2x_fastpath *fp) | ||
203 | @@ -735,9 +701,8 @@ static inline bool bnx2x_fp_lock_poll(struct bnx2x_fastpath *fp) | ||
204 | return false; | ||
205 | } | ||
206 | |||
207 | -static inline bool bnx2x_fp_unlock_poll(struct bnx2x_fastpath *fp) | ||
208 | +static inline void bnx2x_fp_unlock_poll(struct bnx2x_fastpath *fp) | ||
209 | { | ||
210 | - return false; | ||
211 | } | ||
212 | |||
213 | static inline bool bnx2x_fp_ll_polling(struct bnx2x_fastpath *fp) | ||
214 | diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c | ||
215 | index 0a9faa134a9a..2f63467bce46 100644 | ||
216 | --- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c | ||
217 | +++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.c | ||
218 | @@ -1849,7 +1849,7 @@ static void bnx2x_napi_enable_cnic(struct bnx2x *bp) | ||
219 | int i; | ||
220 | |||
221 | for_each_rx_queue_cnic(bp, i) { | ||
222 | - bnx2x_fp_init_lock(&bp->fp[i]); | ||
223 | + bnx2x_fp_busy_poll_init(&bp->fp[i]); | ||
224 | napi_enable(&bnx2x_fp(bp, i, napi)); | ||
225 | } | ||
226 | } | ||
227 | @@ -1859,7 +1859,7 @@ static void bnx2x_napi_enable(struct bnx2x *bp) | ||
228 | int i; | ||
229 | |||
230 | for_each_eth_queue(bp, i) { | ||
231 | - bnx2x_fp_init_lock(&bp->fp[i]); | ||
232 | + bnx2x_fp_busy_poll_init(&bp->fp[i]); | ||
233 | napi_enable(&bnx2x_fp(bp, i, napi)); | ||
234 | } | ||
235 | } | ||
236 | @@ -3191,9 +3191,10 @@ static int bnx2x_poll(struct napi_struct *napi, int budget) | ||
237 | } | ||
238 | } | ||
239 | |||
240 | + bnx2x_fp_unlock_napi(fp); | ||
241 | + | ||
242 | /* Fall out from the NAPI loop if needed */ | ||
243 | - if (!bnx2x_fp_unlock_napi(fp) && | ||
244 | - !(bnx2x_has_rx_work(fp) || bnx2x_has_tx_work(fp))) { | ||
245 | + if (!(bnx2x_has_rx_work(fp) || bnx2x_has_tx_work(fp))) { | ||
246 | |||
247 | /* No need to update SB for FCoE L2 ring as long as | ||
248 | * it's connected to the default SB and the SB | ||
249 | diff --git a/drivers/net/vxlan.c b/drivers/net/vxlan.c | ||
250 | index f8528a4cf54f..fceb637efd6b 100644 | ||
251 | --- a/drivers/net/vxlan.c | ||
252 | +++ b/drivers/net/vxlan.c | ||
253 | @@ -1713,12 +1713,6 @@ static int vxlan6_xmit_skb(struct dst_entry *dst, struct sk_buff *skb, | ||
254 | } | ||
255 | } | ||
256 | |||
257 | - skb = iptunnel_handle_offloads(skb, udp_sum, type); | ||
258 | - if (IS_ERR(skb)) { | ||
259 | - err = -EINVAL; | ||
260 | - goto err; | ||
261 | - } | ||
262 | - | ||
263 | skb_scrub_packet(skb, xnet); | ||
264 | |||
265 | min_headroom = LL_RESERVED_SPACE(dst->dev) + dst->header_len | ||
266 | @@ -1738,6 +1732,12 @@ static int vxlan6_xmit_skb(struct dst_entry *dst, struct sk_buff *skb, | ||
267 | goto err; | ||
268 | } | ||
269 | |||
270 | + skb = iptunnel_handle_offloads(skb, udp_sum, type); | ||
271 | + if (IS_ERR(skb)) { | ||
272 | + err = -EINVAL; | ||
273 | + goto err; | ||
274 | + } | ||
275 | + | ||
276 | vxh = (struct vxlanhdr *) __skb_push(skb, sizeof(*vxh)); | ||
277 | vxh->vx_flags = htonl(VXLAN_HF_VNI); | ||
278 | vxh->vx_vni = md->vni; | ||
279 | @@ -1798,10 +1798,6 @@ int vxlan_xmit_skb(struct rtable *rt, struct sk_buff *skb, | ||
280 | } | ||
281 | } | ||
282 | |||
283 | - skb = iptunnel_handle_offloads(skb, udp_sum, type); | ||
284 | - if (IS_ERR(skb)) | ||
285 | - return PTR_ERR(skb); | ||
286 | - | ||
287 | min_headroom = LL_RESERVED_SPACE(rt->dst.dev) + rt->dst.header_len | ||
288 | + VXLAN_HLEN + sizeof(struct iphdr) | ||
289 | + (skb_vlan_tag_present(skb) ? VLAN_HLEN : 0); | ||
290 | @@ -1817,6 +1813,10 @@ int vxlan_xmit_skb(struct rtable *rt, struct sk_buff *skb, | ||
291 | if (WARN_ON(!skb)) | ||
292 | return -ENOMEM; | ||
293 | |||
294 | + skb = iptunnel_handle_offloads(skb, udp_sum, type); | ||
295 | + if (IS_ERR(skb)) | ||
296 | + return PTR_ERR(skb); | ||
297 | + | ||
298 | vxh = (struct vxlanhdr *) __skb_push(skb, sizeof(*vxh)); | ||
299 | vxh->vx_flags = htonl(VXLAN_HF_VNI); | ||
300 | vxh->vx_vni = md->vni; | ||
301 | diff --git a/fs/exec.c b/fs/exec.c | ||
302 | index c7f9b733406d..00400cf522dc 100644 | ||
303 | --- a/fs/exec.c | ||
304 | +++ b/fs/exec.c | ||
305 | @@ -1265,6 +1265,53 @@ static void check_unsafe_exec(struct linux_binprm *bprm) | ||
306 | spin_unlock(&p->fs->lock); | ||
307 | } | ||
308 | |||
309 | +static void bprm_fill_uid(struct linux_binprm *bprm) | ||
310 | +{ | ||
311 | + struct inode *inode; | ||
312 | + unsigned int mode; | ||
313 | + kuid_t uid; | ||
314 | + kgid_t gid; | ||
315 | + | ||
316 | + /* clear any previous set[ug]id data from a previous binary */ | ||
317 | + bprm->cred->euid = current_euid(); | ||
318 | + bprm->cred->egid = current_egid(); | ||
319 | + | ||
320 | + if (bprm->file->f_path.mnt->mnt_flags & MNT_NOSUID) | ||
321 | + return; | ||
322 | + | ||
323 | + if (task_no_new_privs(current)) | ||
324 | + return; | ||
325 | + | ||
326 | + inode = file_inode(bprm->file); | ||
327 | + mode = READ_ONCE(inode->i_mode); | ||
328 | + if (!(mode & (S_ISUID|S_ISGID))) | ||
329 | + return; | ||
330 | + | ||
331 | + /* Be careful if suid/sgid is set */ | ||
332 | + mutex_lock(&inode->i_mutex); | ||
333 | + | ||
334 | + /* reload atomically mode/uid/gid now that lock held */ | ||
335 | + mode = inode->i_mode; | ||
336 | + uid = inode->i_uid; | ||
337 | + gid = inode->i_gid; | ||
338 | + mutex_unlock(&inode->i_mutex); | ||
339 | + | ||
340 | + /* We ignore suid/sgid if there are no mappings for them in the ns */ | ||
341 | + if (!kuid_has_mapping(bprm->cred->user_ns, uid) || | ||
342 | + !kgid_has_mapping(bprm->cred->user_ns, gid)) | ||
343 | + return; | ||
344 | + | ||
345 | + if (mode & S_ISUID) { | ||
346 | + bprm->per_clear |= PER_CLEAR_ON_SETID; | ||
347 | + bprm->cred->euid = uid; | ||
348 | + } | ||
349 | + | ||
350 | + if ((mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP)) { | ||
351 | + bprm->per_clear |= PER_CLEAR_ON_SETID; | ||
352 | + bprm->cred->egid = gid; | ||
353 | + } | ||
354 | +} | ||
355 | + | ||
356 | /* | ||
357 | * Fill the binprm structure from the inode. | ||
358 | * Check permissions, then read the first 128 (BINPRM_BUF_SIZE) bytes | ||
359 | @@ -1273,36 +1320,9 @@ static void check_unsafe_exec(struct linux_binprm *bprm) | ||
360 | */ | ||
361 | int prepare_binprm(struct linux_binprm *bprm) | ||
362 | { | ||
363 | - struct inode *inode = file_inode(bprm->file); | ||
364 | - umode_t mode = inode->i_mode; | ||
365 | int retval; | ||
366 | |||
367 | - | ||
368 | - /* clear any previous set[ug]id data from a previous binary */ | ||
369 | - bprm->cred->euid = current_euid(); | ||
370 | - bprm->cred->egid = current_egid(); | ||
371 | - | ||
372 | - if (!(bprm->file->f_path.mnt->mnt_flags & MNT_NOSUID) && | ||
373 | - !task_no_new_privs(current) && | ||
374 | - kuid_has_mapping(bprm->cred->user_ns, inode->i_uid) && | ||
375 | - kgid_has_mapping(bprm->cred->user_ns, inode->i_gid)) { | ||
376 | - /* Set-uid? */ | ||
377 | - if (mode & S_ISUID) { | ||
378 | - bprm->per_clear |= PER_CLEAR_ON_SETID; | ||
379 | - bprm->cred->euid = inode->i_uid; | ||
380 | - } | ||
381 | - | ||
382 | - /* Set-gid? */ | ||
383 | - /* | ||
384 | - * If setgid is set but no group execute bit then this | ||
385 | - * is a candidate for mandatory locking, not a setgid | ||
386 | - * executable. | ||
387 | - */ | ||
388 | - if ((mode & (S_ISGID | S_IXGRP)) == (S_ISGID | S_IXGRP)) { | ||
389 | - bprm->per_clear |= PER_CLEAR_ON_SETID; | ||
390 | - bprm->cred->egid = inode->i_gid; | ||
391 | - } | ||
392 | - } | ||
393 | + bprm_fill_uid(bprm); | ||
394 | |||
395 | /* fill in binprm security blob */ | ||
396 | retval = security_bprm_set_creds(bprm); | ||
397 | diff --git a/kernel/bpf/verifier.c b/kernel/bpf/verifier.c | ||
398 | index a28e09c7825d..36508e69e92a 100644 | ||
399 | --- a/kernel/bpf/verifier.c | ||
400 | +++ b/kernel/bpf/verifier.c | ||
401 | @@ -1380,7 +1380,8 @@ peek_stack: | ||
402 | /* tell verifier to check for equivalent states | ||
403 | * after every call and jump | ||
404 | */ | ||
405 | - env->explored_states[t + 1] = STATE_LIST_MARK; | ||
406 | + if (t + 1 < insn_cnt) | ||
407 | + env->explored_states[t + 1] = STATE_LIST_MARK; | ||
408 | } else { | ||
409 | /* conditional jump with two edges */ | ||
410 | ret = push_insn(t, t + 1, FALLTHROUGH, env); | ||
411 | diff --git a/net/core/skbuff.c b/net/core/skbuff.c | ||
412 | index 8e4ac97c8477..98d45fe72f51 100644 | ||
413 | --- a/net/core/skbuff.c | ||
414 | +++ b/net/core/skbuff.c | ||
415 | @@ -4169,19 +4169,21 @@ EXPORT_SYMBOL(skb_try_coalesce); | ||
416 | */ | ||
417 | void skb_scrub_packet(struct sk_buff *skb, bool xnet) | ||
418 | { | ||
419 | - if (xnet) | ||
420 | - skb_orphan(skb); | ||
421 | skb->tstamp.tv64 = 0; | ||
422 | skb->pkt_type = PACKET_HOST; | ||
423 | skb->skb_iif = 0; | ||
424 | skb->ignore_df = 0; | ||
425 | skb_dst_drop(skb); | ||
426 | - skb->mark = 0; | ||
427 | skb_sender_cpu_clear(skb); | ||
428 | - skb_init_secmark(skb); | ||
429 | secpath_reset(skb); | ||
430 | nf_reset(skb); | ||
431 | nf_reset_trace(skb); | ||
432 | + | ||
433 | + if (!xnet) | ||
434 | + return; | ||
435 | + | ||
436 | + skb_orphan(skb); | ||
437 | + skb->mark = 0; | ||
438 | } | ||
439 | EXPORT_SYMBOL_GPL(skb_scrub_packet); | ||
440 | |||
441 | diff --git a/net/ipv4/geneve.c b/net/ipv4/geneve.c | ||
442 | index 5a4828ba05ad..a566a2e4715b 100644 | ||
443 | --- a/net/ipv4/geneve.c | ||
444 | +++ b/net/ipv4/geneve.c | ||
445 | @@ -113,10 +113,6 @@ int geneve_xmit_skb(struct geneve_sock *gs, struct rtable *rt, | ||
446 | int min_headroom; | ||
447 | int err; | ||
448 | |||
449 | - skb = udp_tunnel_handle_offloads(skb, csum); | ||
450 | - if (IS_ERR(skb)) | ||
451 | - return PTR_ERR(skb); | ||
452 | - | ||
453 | min_headroom = LL_RESERVED_SPACE(rt->dst.dev) + rt->dst.header_len | ||
454 | + GENEVE_BASE_HLEN + opt_len + sizeof(struct iphdr) | ||
455 | + (skb_vlan_tag_present(skb) ? VLAN_HLEN : 0); | ||
456 | @@ -131,6 +127,10 @@ int geneve_xmit_skb(struct geneve_sock *gs, struct rtable *rt, | ||
457 | if (unlikely(!skb)) | ||
458 | return -ENOMEM; | ||
459 | |||
460 | + skb = udp_tunnel_handle_offloads(skb, csum); | ||
461 | + if (IS_ERR(skb)) | ||
462 | + return PTR_ERR(skb); | ||
463 | + | ||
464 | gnvh = (struct genevehdr *)__skb_push(skb, sizeof(*gnvh) + opt_len); | ||
465 | geneve_build_header(gnvh, tun_flags, vni, opt_len, opt); | ||
466 | |||
467 | diff --git a/net/ipv4/tcp_output.c b/net/ipv4/tcp_output.c | ||
468 | index 1db253e36045..d520492ba698 100644 | ||
469 | --- a/net/ipv4/tcp_output.c | ||
470 | +++ b/net/ipv4/tcp_output.c | ||
471 | @@ -2929,6 +2929,8 @@ struct sk_buff *tcp_make_synack(struct sock *sk, struct dst_entry *dst, | ||
472 | } | ||
473 | #endif | ||
474 | |||
475 | + /* Do not fool tcpdump (if any), clean our debris */ | ||
476 | + skb->tstamp.tv64 = 0; | ||
477 | return skb; | ||
478 | } | ||
479 | EXPORT_SYMBOL(tcp_make_synack); |